 $ type vaxchelp.hlp
1 CC
 The CC command invokes the VAX-11 C compiler to  compile  C  source
 programs.

      CC file-spec,...  +library-file-spec/LIBRARY...

2 Command_Parameters

 file-spec,...

     One or more C source files separated by plus signs  or  commas.
     If plus signs are used, the input files are concatenated into a
     single object file.  If commas are used, each file is  compiled
     separately  to  create separate object files.  If no input file
     type is specified, C assumes the default file type C.

 library-file-spec

     A text library containing #include modules referenced in one or
     more of the source files.  A library file specification must be
     preceded by a plus sign and  qualified  by  /LIBRARY.   If  the
     input  file  type  is not specified, C assumes the default file
     type TLB.

2 Qualifiers

/CROSS_REFERENCE
/NOCROSS_REFERENCE (D)

     Specifies whether the compiler is to generate  cross-references
     in  the  listing  file.   If  you specify /CROSS_REFERENCE, the
     compiler lists, for each variable referenced in the  procedure,
     the  line  numbers  of  the  lines  on  which  the  variable is
     referenced.  This qualifier implies /LIST and /SHOW=SYMBOLS.

/DEBUG[=(options,...)] (D=TRACEBACK)
/NODEBUG

     Requests that information be included in the object module  for
     use  with  the  VAX-11  Symbolic  Debugger.  You can select the
     following options:

     ALL              Include all possible debug information
     TRACEBACK        Include only traceback records
     NOTRACEBACK      Do not include traceback records
     NONE             Do not include any debugging information

/LIST[=file-spec] (Batch default)
/NOLIST (Interactive default)

     Controls whether a  listing  file  is  produced.   The  default
     output   file   type  is  LIS.   /LIST  is  implied  if  either
     /MACHINE_CODE or /CROSS_REFERENCE is specified.

/MACHINE_CODE
/NOMACHINE_CODE (D)

     Controls whether the listing produced by the compiler  includes
     the  machine  language  code  generated during the compilation.
     This qualifier implies /LIST.

/OBJECT[=file-spec] (D)
/NOOBJECT

     Controls whether the compiler produces an output object module.
     The default output file type is OBJ.

/OPTIMIZE (D)
/NOOPTIMIZE

     Controls whether optimization is performed by the compiler.

/SHOW=(option,...) D=(SOURCE)

     Sets or cancels specific listing options:

     ALL                Print all listing information
     NONE               Print no listing information
     [NO]INCLUDE        Print/do  not  print  contents  of  #include
                        files (D = NOINCLUDE)
     [NO]SOURCE         Print/do not print source file statements (D
                        = SOURCE)
     [NO]STATISTICS     Print/do  not  print  compiler   performance
                        statistics (D = NOSTATISTICS)
     [NO]SYMBOLS        Print/do  not  print  symbol  table   (D   =
                        NOSYMBOLS, unless /CROSS is specified)
     [NO]EXPANSION      Print/do not print  macro  expansions  (D  =
                        NOEXPANSION)
     [NO]INTERMEDIATE   Print/do  not   print   intermediate   macro
                        expansions (D = NOINTERMEDIATE)

/STANDARD=[NO]PORTABLE (D=NOPORTABLE)

     Specifies whether the compiler is to generate warning  messages
     to   flag  VAX-11  C  language  extensions  and  relaxation  of
     conventional C constructs  and  rules  (PORTABLE),  or  not  to
     generate     them     (NOPORTABLE).      The     default     is
     /STANDARD=NOPORTABLE.

/WARNINGS (D)
/NOWARNINGS

     Controls whether the compiler prints  messages  for  diagnostic
     warnings.

/LIBRARY

     Indicates  that  the  associated  input  file  is   a   library
     containing  source  text  modules specified in #include control
     lines.  The compiler searches the  specified  library  for  all
     #include  module  names that are not enclosed in angle brackets
     or quotation marks.  The name of the library must  be  preceded
     by a plus sign.

     Example:  CC APPLIC+DATAB/LIBRARY

2 Errors
 VAX-11 C compiler error messages.

3 ANACHRONISM

 Message       The "******" operator is an obsolete  form,  and  may
               not be portable.

 Warning       You have used an old-style operator such as =+ or =*.
               The  message is issued only if the /STANDARD=PORTABLE
               qualifier is specified in the CC command line.

 User Action   For the program to be portable,  you  should  reverse
               the order of the operator.  For example, =+ should be
               += and =* should be *=.   These  old-style  operators
               are  supported  by  VAX-11  C  but  they  may  not be
               supported by other C compilers.

3 ARGLIST

 Message       Length of  argument  list  for  "*****"  exceeds  VAX
               architecture limit of 255 longwords.

 Error         The VAX procedure-calling architecture does not allow
               argument lists to be longer than 255 longwords.

 User Action   Reduce the number and/or size  of  arguments  in  the
               function  reference  and  the  corresponding function
               definition.   If  any  arguments  are  structures  or
               union, pass them by reference rather than by value.

3 ARGNOTPORT

 Message       Passing a structure by value is not portable.

 Warning       This message occurs when a  structure  is  passed  by
               value   in  a  function  call,  or  when  a  function
               parameter is declared as a structure,  and  when  the
               /STANDARD=PORTABLE  option  is used in the CC command
               line.

 User Action   If the program must be portable, pass the  structure,
               by reference, as a pointer to the structure.

3 ARGOVERFLOW

 Message       Length  of  macro  argument   list   exceeds   buffer
               capacity;   overflowing  argument(s) considered to be
               null.

 Warning       The  total  length  of  the  arguments  in  a   macro
               reference  exceeds  the  compiler's capacity to store
               the arguments prior to substitution.

 User Action   To avoid  this  message  and  unpredictable  results,
               shorten one or more arguments.

3 ASNDATTYPE

 Message       Target of  assignment  operator  is  noncomputational
               data type.

 Error         You have specified, as the left-hand  operand  of  an
               assignment  operator, an expression that is not valid
               for assignment.   For  example,  you  have  tried  to
               assign something to an array or function.

 User Action   Correct the statement.  The assignment target must be
               a  scalar  variable (including a scalar array element
               or   structure   member),   structure,   union,    or
               dereferenced pointer.

3 ASNREADONLY

 Message       Target of assignment operator is read-only.

 Error         You have attempted to assign a value to a "read-only"
               object.   These  objects  include  literal constants,
               enumerated constants, and variables declared with the
               storage class readonly.

 User Action   If you specified a constant, replace it with a  valid
               assignment  target.   If  you  specified  a  readonly
               variable,  remove  the  readonly  keyword  from   its
               definition.

3 BADAUTOINIT

 Message       The automatic initialization for "****" is not valid.
               It has been ignored.

 Warning       Automatic character arrays cannot be initialized with
               string constants.  This is a temporary restriction.

 User Action   Initialize  the  array  with  an  explicit  list   of
               characters  or copy the string to the array using the
               strcpy function.

3 BADCODE

 Message       Invalid code generation sequence.

 Fatal         An internal compiler error occurred.

 User Action   Gather as much  information  as  you  can  about  the
               conditions  in  effect  when  the error occurred, and
               submit an SPR.

3 BADIFEVAL

 Message       ****  while  evaluating   #if   expression;    "true"
               expression assumed.

 Warning       The substitution text is "Stack overflow" or  "Divide
               by zero".  The expression was taken to be "true."

 User Action   Reevaluate  the  line  and   make   the   appropriate
               corrections.

3 BADMODULE

 Message       Redundant #module control line;  line ignored.

 Warning       You specified more than one #module control line in a
               single compilation;  the excess line(s) were ignored.

 User Action   To avoid this message, remove the extra line(s).

3 BADPARDCL

 Message       "****" is not a named formal parameter in the defined
               function.  It has been declared as auto.

 Warning       You declared the specified identifier as  a  function
               parameter  and  the identifier does not appear in the
               parameter list.  For example:

                    f(a) int a,b;  {...}

               The identifier b was declared as an auto variable  in
               the defined function.

 User Action   The identifier's declaration is  nonportable  and  is
               possibly  a programming error.  To avoid this message
               and unpredictable results, correct the declaration or
               function definition.

3 BADPSECT

 Message       The  program  section  (psect)  specified   by   this
               statement  has  conflicting  READONLY attributes with
               another definition of the same program section.

 Warning       You have specified two or more references to the same
               program  section,  and  they  do  not agree as to the
               program  section's  attributes.   For  example,  this
               message  can  appear  when  two globaldef definitions
               appear for the same name, but only one specifies  the
               storage class readonly.

 User Action   To avoid this message and unpredictable results, make
               all references to a program section consistent.

3 BADSUBVAL

 Message       Array subscripts must  be  specified  for  subscripts
               other than the first.

 Warning       You  omitted  too  many  subscripts  from  an   array
               declaration.   A  subscript  (the number of elements)
               can be omitted if there is only  one  dimension.   If
               there   is   more   than  one  dimension,  the  first
               (leftmost) pair of brackets in the declaration can be
               omitted.   This  applies  equally  to declarations of
               array parameters and extern declarations of arrays.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct  the declaration, specifying a size for every
               dimension after the first.

3 BADUNARY

 Message       The operand of a **** operator was noncomputational.

 Error         You specified an expression of an illegal type with a
               unary operator, such as ++function-call or --union.

 User Action   Replace the operand with an expression valid for  the
               illustrated operator.

3 BADVINIT

 Message       "****" is a value.  It may be initialized only with a
               constant expression.

 Warning       You attempted to  initialize  a  globalvalue  with  a
               nonconstant initializer.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the initializer.

3 BINNONCOMPUT

 Message       The  ****   operand   of   a   "****"   operator   is
               noncomputational.

 Error         Either the left or right operand of  the  illustrated
               operator   is   an   illegal   data   type,   as   in
               function-name+2.

 User Action   Specify an expression that is valid for use with  the
               operator.

3 BUGCHECK

 Message       Compiler bug check during ****.  Submit an SPR with a
               problem description.

 Fatal         An internal error occurred during the specified phase
               of compilation.

 User Action   Gather as much  information  as  possible  about  the
               conditions in which the error occurred, including the
               phase of compilation, and submit an SPR.

3 CASECONSTANT

 Message       Case label value is not a constant expression.

 Error         You specified a value in a case label that was not  a
               constant.

 User Action   Replace  the  case  value  with  a   valid   constant
               expression.

3 CASERANGE

 Message       Case label value **** is not expressible as a  16-bit
               signed   integer  in  the  range  -32,768  to  32,767
               inclusive.

 Error         You specified a value in a case  label  that  is  not
               expressible  in a signed 16-bit integer (that is, not
               in the  range  -32,768  to  32,767).   The  VAX-11  C
               compiler  restricts  the  value  of  a  case label to
               within these limits.  In the message text,  the  case
               label has been replaced by its decimal equivalent.

 User Action   Correct the case label so that it is  expressible  in
               16 bits.

3 CMPLXINIT

 Message       "****" is too complex to initialize.

 Warning       The depth of the indicated aggregate variable exceeds
               the limit of 32 levels.

 User Action   To avoid  this  message  and  unpredictable  results,
               simplify   or   correct   the   initializer  list  or
               declaration.  Otherwise, initialize the variable with
               explicit assignments.

3 COMPILERR

 Message       Previous  errors   prevent   continued   compilation.
               Please correct reported errors and recompile.

 Fatal         The  compiler  has  detected  too  many   errors   to
               continue.

 User Action   Correct the errors reported in the compiler  messages
               previous to this one.

3 CONFLICTDECL

 Message       This declaration of "*****" conflicts with a previous
               declaration of the same name.

 Warning       A name has been redeclared and the data types  and/or
               organizations  are  different.   Any reference to the
               name  resolves  to  the  most   recent   declaration,
               according to the scope rules.

 User Action   The purpose of this message is  to  call  a  possible
               programming error to your attention.

3 DEFTOOLONG

 Message       Text in #define  control  line  is  too  long;   line
               ignored.

 Warning       The length of the token string in  the  #define  line
               exceeds the implementation's limit.

 User Action   To avoid  this  message  and  unpredictable  results,
               shorten or otherwise simplify the line.

3 DIVIDEZERO

 Message       Constant expression includes  divide  by  zero;   the
               result has been replaced with 0.

 Warning       A division by zero  was  encountered  in  a  constant
               expression.  The expression was replaced by 0.

 User Action   Check your constant expressions and correct  the  one
               that is causing the error.

3 DUPCASE

 Message       Case label value **** is a duplicate.

 Error         You  have  specified  more  than  one  case  for  the
               indicated  value  in  a  switch statement.  The cases
               must be unique.

 User Action   Change the case labels and/or combine the  cases,  as
               appropriate.

3 DUPDEFAULT

 Message       Duplicate default label in switch statement.

 Error         You specified more than one default case in the  same
               switch statement.

 User Action   Combine the cases or make other changes necessary  to
               eliminate the duplicate(s).

3 DUPLDEF

 Message       Duplicate definition of "*****".

 Warning       The named definition appears more than  once  in  the
               program.   The  two  definitions  are essentially the
               same.  Both definitions specify the same  data  types
               and  organizations,  but  there may be differences in
               the values, initializers, or array  bounds.   If  the
               name  is a function, there may be a difference in the
               number or types of parameters, or in the contents  of
               the function body.

 User Action   The purpose of this message is  to  call  a  possible
               programming error to your attention.

3 DUPLICATE

 Message       Duplicate label "****".

 Error         You have specified duplicates of the indicated  label
               in  the  same  function.   Label  identifiers must be
               unique within a function definition.

 User Action   Rewrite the labels (and goto statements that refer to
               them) to eliminate the duplicates.

3 DUPLPARM

 Message       Duplicate macro parameter "****" ignored.

 Warning       The indicated macro parameter occurred more than once
               in  #define  line's parameter list.  All instances of
               it after the first were ignored.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the line.

3 DUPMEMBER

 Message       Duplicate declaration of member "*****".

 Warning       The same name has been used for more than one  member
               of  the  same  structure or union.  Any references to
               this member name will be ambiguous.  This message  is
               issued  only when the duplicate names appear within a
               single structure or union.  The  same  names  can  be
               used in two different structures or unions, including
               nested ones.

 User Action   Rename the member(s) so that all members  within  the
               structure or union have unique names.

3 ENUMCLASH

 Message       Mismatched enum type in "****" operation.

 Warning       This   message    is    issued    only    when    the
               /STANDARD=PORTABLE   qualifier  is  used  in  the  CC
               command line.  The indicated  operation  combines  an
               enum  variable or value with a value of a nonmatching
               type.

 User Action   To avoid this message and unpredictable results,  use
               a cast operation to cast either the enum value or the
               other value to a matching type.

3 ENUMOP

 Message       "****" is an undefined  operation  for  enum  values;
               enum operand(s) converted to int.

 Warning       This   message    is    issued    only    when    the
               /STANDARD=PORTABLE   qualifier  is  used  in  the  CC
               command line.  The operators that cannot be used with
               an enumerator are:  logical not (!), one's complement
               (~), prefix and postfix increment and  decrement  (++
               and  --),  all  the arithmetic operators (+, -, *, /,
               and %), all compound assignment  operators  (+=,  -=,
               *=,  /=,  and  %=),  and  the unary minus (-).  These
               operators yield integers, which are incompatible with
               enumerated types.

 User Action   Cast the enum operands to int.

3 ERRORSUM

 Message       Completed with severe errors.

 Fatal         The compilation is complete, but there were too  many
               errors to produce an object file.

 User Action   Correct the errors reported in the previous  compiler
               messages.

3 EXTRAARGS

 Message       Too  many  arguments   specified   for   a   function
               reference.  Only the first 253 will be passed.

 Warning       You  have  called  a  function  with  more  than  253
               arguments.

 User Action   To avoid  this  message  and  unpredictable  results,
               shorten the argument list.

3 EXTRACOMMA

 Message       Extraneous comma in macro parameter list ignored.

 Warning       The #define macro definition on this line  has  extra
               commas that were ignored.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the line.

3 EXTRATEXT

 Message       Extraneous text in preprocessor control line ignored.

 Warning       Extraneous text appears in the control line, as in:

                    #endif ABC

 User Action   To avoid this message, correct the line.

3 FATALSYNTAX

 Message       Fatal syntax error.

 Fatal         The compiler cannot continue due to syntax errors.

 User Action   Correct the error in the indicated line and/or errors
               reported in previous compiler messages.

3 FIELDBADSIZE

 Message       "****" is an invalid field declaration.   Fields  may
               be up to 32 bits in length.  Size of 32 bits assumed.

 Warning       The indicated field declaration is invalid because it
               specifies too large a size.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct  the  declaration to specify either a single,
               smaller field or several  contiguous  fields.   Note,
               however, that field alignments are nonportable.

3 FIELDBADTYPE

 Message       "****" is an invalid field declaration.  Fields  must
               be declared as integers (signed or unsigned) or enum.
               The data type unsigned has been assumed.

 Warning       You have declared a field with an invalid data  type.
               Fields must be declared (and manipulated) as unsigned
               or enumerated types.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the declaration to specify a valid data type.

3 FILEUNOPEN

 Message       Unable to open the **** file.

 Fatal         The compiler cannot continue because of  the  failure
               to open the indicated file.

 User Action   Be sure that the file exists if it is an input  file,
               or  change  the  file specification in the program to
               that of an existing file.

3 FNDUPLPARM

 Message       Duplicate function formal parameter "****" ignored.

 Warning       The stated function parameter occurred more than once
               in the function's formal parameter list, as in:

                    funct(a,b,c,a) {...}

               All occurrences of the parameter after the first were
               ignored.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the line.

3 FNPARMREDECL

 Message       Function formal parameter "****" has been redeclared.

 Warning       Your source program contains a declaration of one  of
               the function's formal parameters, as in:

                    f(a) { int a;  }

 User Action   Verify that this is what you want to do.   If  it  is
               not, correct the declaration(s).

3 FUNCBADECL

 Message       "****"  is  not  properly  declared.   The   function
               attribute will be ignored.

 Warning       You have used the "function attribute" in an  illegal
               manner  in  the  definition  of the indicated object;
               for example, you have declared an array of  functions
               instead  of  an  array of pointers to functions.  The
               function attribute was dropped.

 User Action   Check the definition carefully to be sure that it  is
               logical  and  is  what you intended.  In general, you
               should correct definitions that raise this warning.

3 IFNOMACSUB

 Message       Macro substitution cannot  be  performed  during  the
               scan  of  a macro reference;  "****" not substituted;
               "true" expression assumed.

 Warning       You have written a complex macro  reference  with  an
               #if  control  line  and another macro reference, such
               as:

                    macref(arg1,
                    #if SUBST
                        .
                        .
                        ,arg2)

               where SUBST has a substitution defined in a  previous
               #define line.  The substitution (here, for SUBST) was
               not performed, and the truth  value  of  the  control
               line was assumed to be true.

 User Action   To avoid  this  message  and  unpredictable  results,
               replace  the  #if  macro  reference  with  its actual
               value, or restructure the #if construct so that it is
               not within the complex macro reference.

3 FUNCNOTDEF

 Message       Static  function  "****"  is  not  defined  in   this
               compilation;  assumed to be external.

 Warning       You have referenced a function that was declared with
               the  static  storage  class,  but  which has not been
               defined anywhere in  the  current  compilation  unit.
               The  compiler  assumes  that  the  reference is to an
               externally- defined function, to be resolved at  link
               time;   its storage class is effectively changed from
               static to extern.

 User Action   Remove the static storage class from the  declaration
               of  the  function, or include the function definition
               in the compilation unit.

3 IFSYNTAX

 Message       Syntax error in #if  expression;   "true"  expression
               assumed.

 Warning       The #if expression on the indicated  line  cannot  be
               evaluated because of syntax errors;  it is assumed to
               be "true."

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the line.

3 INCDECTAR

 Message       The operand of a **** operator is not an lvalue.

 Error         You have specified an invalid operand with the --  or
               ++  operator.  The operand must be an lvalue, such as
               a variable reference or a dereferenced pointer.

 User Action   Replace the operand with an lvalue.

3 INCMODNOTPORT

 Message       #include of a library module is not portable.

 Warning       The specification of a  library  module  name  in  an
               #include  preprocessor  control  line  is  a VAX-11 C
               extension and  is  not  portable.   This  message  is
               issued  only  if  the  /STANDARD=PORTABLE  option  is
               specified in the CC command line.

 User Action   No  action  is  necessary  if  you  do  not   require
               compatibility with other C compilers.

3 INCNESTLVL

 Message       Include files may only be nested 4 levels.

 Fatal         You have  specified  a  tree  of  #include  files  or
               modules    that   are   too   deeply   nested.    The
               implementation limit is four.

 User Action   If you  need  all  the  text  you  specified  in  the
               #include  lines, explicitly include some of it in the
               source file.

3 INCOMDT

 Message       **** is an invalid data  type  in  this  declaration.
               All but the first data type ignored.

 Warning       You specified the indicated data type  keyword  in  a
               declaration or definition that already had one, as in
               float int.  The resulting type  in  this  example  is
               float.

 User Action   Check carefully to see which type the  object  should
               have, and remove all extraneous keywords.

3 INCOMSC

 Message       **** is an invalid storage class in this declaration.
               Only the first storage class is used.

 Warning       The indicated storage  class  keyword  appears  in  a
               declaration or definition that already has one, as in
               auto register.  Only the first one  (here,  auto)  is
               used.

 User Action   Check carefully to see which type the  object  should
               have, and remove all the extraneous keywords.

3 INCPTRSUB

 Message       Inconsistent pointer subtraction;  two  pointers  may
               be  subtracted only if they point to equivalent-sized
               objects.

 Error         You subtracted two pointers that do not point to  the
               same  data  type  or  objects  of  equal  size.   The
               subtraction is an invalid operation.

 User Action   Change or cast the operands to point  to  equal-sized
               objects.

3 INITBIT

 Message       "****" is a field.  Static fields may be  initialized
               only with constants.

 Warning       You have initialized the  indicated  structure  field
               with a variable.

 User Action   The field may not be properly initialized.  To  avoid
               this  message  and  unpredictable  results, specify a
               constant initializer.

3 INTPOINTER

 Message The use of an integer value as  a  pointer  qualifier  (for
               "****") is not portable.

 Warning       In  a  reference  to  a  structure  or  union  member
               accessed   via  the  "->"  operator,  the  qualifying
               expression to the left of  the  "->"  should  have  a
               pointer  value.   VAX  C  allows  the  use of integer
               values as well, but such usage is not portable.  This
               message  is  issued  only  if  /STANDARD=PORTABLE was
               specified.

 User Action   To avoid this message,  either  use  a  true  pointer
               expression  as  the  qualifier,  or  cast the integer
               expression  as  an  appropriate  structure  or  union
               pointer.

3 INTVALREQ

 Message       A non-integer value has been used  incorrectly  in  a
               ****;  it has been converted to int.

 Warning       A noninteger value is not  valid  as  used.   It  was
               coerced to int.

 User Action   To avoid  this  message  and  unpredictable  results,
               change or cast the operand to an integral type.

3 INVADDR

 Message       Invalid "address of" operand.

 Error         You have used the "address of" (&) operator  with  an
               invalid operand.  The operand must be an lvalue, such
               as the name of a variable.

 User Action   Replace the operand with an lvalue.

3 INVAGGASN

 Message       Invalid aggregate  assignment;   union  =  union  and
               structure = structure are valid if the source and the
               target are of equal size.

 Error         You have attempted to  assign  an  array  to  another
               array  or to assign structures or unions of different
               sizes.

 User Action   Correct the assignment.

3 INVALIDIF

 Message       "****" is not a valid constant or operator in an  #if
               expression;  "true" expression assumed.

 Warning       You have used  an  invalid  construction  in  an  #if
               expression, which is assumed to be true.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the line.

3 INVALINIT

 Message       The initialization of "****" is not valid.

 Warning       The  indicated  object  cannot  be   initialized   as
               specified.   Some  objects  may not be initialized at
               all,  such  as  functions,  unions,  and  extern   or
               globalref  objects.   In other cases, the initializer
               may not be appropriate, for example, a static pointer
               cannot   be   initialized  with  the  address  of  an
               automatic variable.  Any subsequent initializers  for
               the same object have been ignored.

 User Action   To avoid  this  message  and  unpredictable  results,
               eliminate  or correct the initializer, or correct the
               type or  storage  class  of  the  target  object,  or
               initialize the object with an explicit assignment.

3 INVARRAY

 Message       "****" is an improperly declared array.

 Warning       You have improperly declared an  array,  such  as  an
               array of functions.

 User Action   The declared object is probably not what you  wanted.
               To  avoid  this  message  and  unpredictable results,
               correct the declaration.

3 INVBREAK

 Message       break statement used in an invalid context.  break is
               valid only in for, while, do, and switch statements.

 Error         You have used break outside the body of  any  of  the
               indicated statements.

 User Action   Remove the offending break.

3 INVCMDVAL

 Message       "****" is an invalid command qualifier value.

 Warning       The  indicated  CC  command   qualifier   value   was
               acceptable    to   the   VAX/VMS   command   language
               interpreter (CLI), but it is meaningless to VAX-11 C;
               for example, LIST_OPTS is an invalid value for /SHOW,
               although it is accepted by the CLI.

 User Action   Correct the qualifier value.

3 INVCONDEXPR

 Message       The  second  and  third  operands  of  a  conditional
               expression cannot be converted to a common type.

 Error         The  second  and  third  operands  of  a  conditional
               expression   must   be   expressions   which  can  be
               converted, if  necessary,  to  a  common  type.   For
               arithmetic    operands,    the    "usual   arithmetic
               conversions" are performed.  If either operand  is  a
               pointer,  the  other  must  be  a pointer of the same
               type, or it may be the constant 0.  If either operand
               is  a  structure  or  union,  the  other  must  be  a
               structure or union of the same size.

 User Action   Correct the invalid operand, perhaps by using a  cast
               operator  (but note that structures or unions may not
               be cast).

3 INVCONST

 Message       "****" is an invalid numeric constant.

 Warning       The indicated constant has illegal characters  or  is
               otherwise invalid.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the constant.

3 INVCONTINUE

 Message       continue  statement  used  in  an  invalid   context.
               continue   is  valid  only  in  for,  while,  and  do
               statements.

 Error         You have used the continue statement outside the body
               of any of the listed statements.

 User Action   Remove the offending continue.

3 INVCONVERT

 Message       The   source   or   target   of   a   conversion   is
               noncomputational.

 Error         One of the operands in the indicated line  cannot  be
               converted   as  specified.   For  example,  you  have
               attempted to cast some object to a structure.

 User Action   Correct the operation.

3 INVDEFNAME

 Message       Missing or invalid name in **** control  line;   line
               ignored.

 Warning       The control line is missing a required name, as in:

                    #define

               The entire line was ignored.

 User Action   To avoid this message, correct or remove the line.

3 INVFILESPEC

 Message       Missing or invalid  file  specification  in  #include
               control line;  line ignored.

 Warning       The #include line either is missing a file or  module
               name  or specifies one that is syntactically invalid.
               The line was ignored.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the line.

3 INVFOPT

 Message       Invalid function definition option ignored.

 Warning       You have specified a function definition option  that
               is   not   supported.    The  only  valid  option  is
               main_program.

 User Action   To avoid this message, correct the line.

3 INVHEXCON

 Message       Hexadecimal constant contains an invalid character.

 Error         You have specified an invalid  hexadecimal  constant,
               such as 0xG.

 User Action   Correct the constant.

3 INVIFNAME

 Message       Missing or invalid name in #ifdef or #ifndef  control
               line;  "true" assumed.

 Warning       You  have  specified  no  name,  or  a  syntactically
               invalid  one, in the control line;  the result of the
               test is assumed to be true.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the line.

3 INVLINEFILE

 Message       Invalid  file  specification  in  #line  preprocessor
               control line;  line ignored.

 Warning       The file specification is syntactically invalid,  and
               the control line was ignored.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the line.

3 INVLINELINE

 Message       Missing or invalid line number in #line  preprocessor
               control line;  line ignored.

 Warning       The  line  number  is  missing  or  is  syntactically
               invalid, and the control line was ignored.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the line.

3 INVMODIDENT

 Message       Invalid ident in #module preprocessor  control  line;
               line ignored.

 Warning       The ident specified in the control line either is not
               a valid identifier or is not a valid character-string
               constant.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the line.

3 INVMODTITLE

 Message       Missing or invalid  title  specification  in  #module
               preprocessor control line;  line ignored.

 Warning       The required title in  the  control  line  either  is
               missing or is not a valid identifier.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the line.

3 INVOCTLCHAR

 Message       Invalid  octal  character  value;   high-order   bits
               truncated.

 Warning       The octal value in an escape sequence is  too  large,
               as in '\477'.  Its high-order bits are truncated.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the constant.

3 INVPPKEYWORD

 Message       Missing or invalid keyword  in  preprocessor  control
               line;  line ignored.

 Warning       You have written a control line with no  keyword,  as
               in:

                    # ABC

               The line was ignored.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the line.

3 INVPTRADD

 Message       Invalid pointer addition;  the  only  valid  form  of
               pointer addition is "pointer +[=] integer".

 Error

 User Action   Correct the operation.

3 INVPTROPER

 Message       Invalid pointer arithmetic;  the only math operations
               defined for pointers are addition and subtraction.

 Error

 User Action   Correct the operation.

3 INVPTRSUB

 Message       Invalid pointer subtraction;  the only valid forms of
               pointer   subtraction  are  "pointer  -  pointer"  or
               "pointer -[=] integer".

 Error

 User Action   Correct the operation.

3 INVQUAL

 Message       One of the command qualifiers is meaningless.

 Warning       One  (or  more)  of  the  CC  command  qualifiers  is
               meaningless   to  VAX-11  C,  although  grammatically
               acceptable   to   the   VAX/VMS   command    language
               interpreter.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the qualifier's name.

3 INVSUBS

 Message       Invalid subscript value.  Subscripts must be  int  or
               unsigned.   Subscripts in array declarations or casts
               must also be constants.

 Error         You have written an invalid  subscript  in  an  array
               reference  or  declaration, or cast.  Subscripts used
               in  array  declarations  and  casts  must   also   be
               constants.  For example, you have put a decimal point
               on the constant subscript, making its type double.

 User Action   Correct the subscript.

3 LIBERROR

 Message       Error while reading library "****".

 Fatal         The  compiler  cannot  read  the  indicated  library.
               Either  it  is  not  a text library or its format has
               been corrupted.

 User Action   Verify the spelling of the library's name, and verify
               that it is a valid VAX/VMS text library.

3 LIBLOOKUP

 Message       "****"  was  not  found  in  any  of  the   specified
               libraries.

 Fatal         The compiler failed to locate the indicated  #include
               module in any of the specified or default libraries.

 User Action   Check the CC command line to verify that the  library
               containing  the  module  was  specified  and that the
               module name, if specified, was spelled correctly.  If
               the  library was a default library, verify (with SHOW
               TRANSLATION  C$LIBRARY)  that   its   name   is   the
               equivalent for C$LIBRARY.

3 MACDEFINREF

 Message       A macro cannot be **** during the scan of a reference
               to the macro;  line ignored.

 Warning       You have tried to redefine or undefine a macro within
               a reference to it.  The line was ignored.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the line.

3 MACNONTERMCHAR

 Message       Nonterminated character constant in  macro  argument;
               apostrophe added at end of line.

 Warning

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the line.

3 MACREQARGS

 Message       Macro reference requires an  argument  list;   "****"
               not substituted.

 Error         You  have  written  a  macro  reference  without   an
               argument  list.   The  reference was deleted from the
               source file.

 User Action   Correct the reference, specifying the same number  of
               arguments as in the definition of the macro.

3 MACSYNTAX

 Message       Syntax error in macro definition;  line ignored.

 Warning

 User Action   Correct the error and recompile.

3 MACUNEXPEOF

 Message       Unexpected  end-of-file  encountered   in   a   macro
               reference;  "****" not substituted.

 Error         The  end-of-file  was  encountered  during  a   macro
               reference;  the reference was deleted.

 User Action   Correct the error and recompile.

3 MAXMACNEST

 Message       Maximum  text  replacement  nesting  level  exceeded;
               "****" not substituted.

 Error         You  have  specified  a  macro  reference  which   is
               recursive  or otherwise causes repeated substitutions
               to a depth greater than the implementation's  maximum
               of 64.

 User Action   Correct the recursion or simplify the definition.

3 MISPARENS

 Message       Mismatched parentheses  in  #if  expression;   "true"
               expression assumed.

 Warning

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the line.

3 MISSEDIT

 Message       Misplaced parentheses in function definition.

 Error         The parentheses are either missing  or  misplaced  in
               the function definition, as in:

                    double f { function-statement }

               In the example, the function name f must be  followed
               by  a pair of parentheses, even if the function takes
               no parameters.

 User Action   Correct the function definition.

3 MISSENDIF

 Message       Missing #endif preprocessor control line(s).

 Error         The compiler did not encounter an #endif line for the
               most recent #if, #ifdef, or #ifndef.

 User Action   Be  sure  that  the  control   lines   are   properly
               structured,   and   add   the   missing   #endif   if
               appropriate.

3 MISSEXP

 Message       Missing or invalid exponent in float constant;   zero
               exponent ('e0') assumed.

 Warning       You have written a floating-point constant  with  the
               letter  'e' or 'E' but with no exponent or an invalid
               exponent.  The exponent is assumed to be zero.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the constant.

3 MODNOMACSUB

 Message       Macro substitution cannot  be  performed  during  the
               scan  of  a macro reference;  "****" not substituted;
               line ignored.

 Warning       You have  written  a  complex  macro  reference  that
               includes   a  #module  line  that  contains  a  macro
               reference as in:

                    macref(arg1,
                    #module SUBST
                        .
                        .
                        ,arg2)

               where SUBST has a substitution defined in a  previous
               #define line.  The substitution (here, for SUBST) was
               not performed, and the #module line was ignored.

 User Action   To avoid  this  message  and  unpredictable  results,
               replace  the  reference  to  the macro in the #module
               line with its actual value or move the  #module  line
               to a position outside the complex macro reference.

3 MODNOTPORT

 Message       The  #module  preprocessor  control   line   is   not
               portable.

 Warning       You have used the #module line correctly, but you are
               warned  that  it  is  unique  to  VAX-11  C  and  not
               portable.

 User Action   This  message  occurs  when  the   /STANDARD=PORTABLE
               option is used in the CC command line.

3 MODZERO

 Message       Constant expression includes mod  zero;   the  result
               has been replaced with 0.

 Warning       The  constant   expression   has   an   invalid   mod
               expression, such as 5 % 0.  The result is zero.

 User Action   Correct the expression (but note  that  its  operands
               must not be float).

3 NAMETOOLONG

 Message       Identifier name exceeds 31 characters;  truncated  to
               "****".

 Warning

 User Action   To  avoid  this  message,   shorten   the   indicated
               identifier.

3 NESTEDCOMMENT

 Message       Nested comment encountered.

 Warning       You have included one comment inside another,  as  in
               /*  /*  comment  */.   This  message occurs only when
               compiled with the /STANDARD=PORTABLE option.

 User Action   Check that you have not misplaced a comment deliniter
               and inadvertently "commented out" necessary code.

3 NOBJECT

 Message       No object file produced.

 Informational The compiler did not produce an object file,  due  to
               conditions reported in previous message(s).

 User Action   Perform  the  corrections  suggested  by  the   other
               messages.

3 NOCLI

 Message       This compiler can be run only from VAX/VMS DCL.

 Fatal

 User Action   Recompile the program, using the CC command only with
               the standard command language DCL.

3 NOFLOATOP

 Message       The **** operand of  an  ****  operator  may  not  be
               floating point.  The operand has been converted to an
               integer.

 Warning       The left or right operand  of  the  indicated  binary
               operator,  or  the  operand  of  the  indicated unary
               operator, cannot be of type float or double.  It  was
               coerced to int.

 User Action   To avoid  this  message  and  unpredictable  results,
               change or cast the operand to an integral type.

3 NOFORMALS

 Message       The declaration/definition of "****" specifies one or
               more  function  formal  parameters  which  have  been
               ignored.

 Warning       You have included a function's formal parameters in a
               function definition or declaration.  For example, the
               following function declaration is not allowed because
               it names the function's parameters:

                    int funct(a,b,c);

               The parameters a, b, and c are ignored.

               Similarly,  the  following  example   inappropriately
               defines  a function returning a pointer to a function
               returning an integer.  The names of the parameters of
               the function returning an integer are not allowed:

                    (*f(p1,p2))(q1,q2)
                    int p1,p2;
                    { ... }

 User Action   To avoid this message, remove the parameters, as in:

                    int funct();
               and
                    (*f(p1,p2))()

3 NOLABEL

 Message       Label "****" undefined in this function.

 Error         You have written "goto label-name" for  an  undefined
               label.   The  scope  of a label name is restricted to
               the function in which it is used as a label, and goto
               statements  cannot  branch  to  labels  inside  other
               functions.

 User Action   If appropriate, define the appropriate label name  by
               labeling  a  statement  in  the  same function as the
               goto.

3 NOLISTING

 Message       No listing file produced.

 Informational The compiler did not create a listing  file,  usually
               due to previously reported errors.

 User Action   None.

3 NONOCTALDIGIT

 Message       Octal  escape  sequence  in  a  character  or  string
               constant terminated by nonoctal digit.

 Warning       There is an 8 or 9 in the second or third position of
               an  octal  escape sequence.  In this case, the digits
               preceding the nonoctal digit are evaluated and the  8
               or 9 is considered a separate character.

 User Action   This message is issued only if the /STANDARD=PORTABLE
               option  is  used  in  the CC command line.  Make sure
               that  the  compiler  has   resolved   the   ambiguity
               correctly.

3 NONOCTALESC

 Message       Escape sequence in a  character  or  string  constant
               starts with a nonoctal digit.

 Warning       The first of three digits of an escape sequence is an
               8  or  9.  In this case, the backslash is ignored and
               the 8 or 9 is treated as a character.

 User Action   This message is issued only if the  /STANDARD  option
               is  used  in the CC command line.  Make sure that the
               compiler has resolved the ambiguity correctly.

3 NONPORADDR

 Message       Ampersand with constant is not a portable operation.

 Warning       You have used an ampersand operator with  a  constant
               in  the  argument  list of a function call.  VAX-11 C
               permits this special case, but you  are  warned  that
               the  use  of the ampersand on anything but lvalues is
               not portable.

 User Action   You can suppress the  message  with  the  CC  command
               qualifier /STANDARD=NOPORTABLE, which is the default.

3 NONPORTCONST

 Message       **** is a nonportable character constant.

 Warning       VAX-11 C allows up to four characters to be specified
               in  a character constant;  constants of more than one
               character, however, are not portable.

 User Action   You can suppress the  message  with  the  CC  command
               qualifier /STANDARD=NOPORTABLE, which is the default.

3 NONPORTSC

 Message       **** is a nonportable storage class specifier.

 Warning       This message is issued  for  the  use  of  globalref,
               globaldef,  globalvalue,  and  readonly storage class
               specifiers when the /STANDARD=PORTABLE option is used
               in the CC command line.

 User Action   No action is required if  the  program  need  not  be
               compatible  with  other  C  compilers.  You can avoid
               this message by not specifying /STANDARD=PORTABLE.

3 NONSEQUITUR

 Message       "****" is not a member of the specified structure  or
               union.

 Warning       You have used a member  name  in  a  reference  to  a
               structure or union in which it was not declared.  The
               reference was  valid,  because  the  member  name  is
               unique  and refers unambiguously to a location in the
               referenced structure.  This use of  member  names  is
               maintained   only   for   compatibility   with  older
               programs.

 User Action   The message can be  inhibited  by  using  a  properly
               declared    member    name    or    by    using   the
               /STANDARD=NOPORTABLE option in the command line.

3 NONTERMCHAR

 Message       Nonterminated character constant;  **** assumed.

 Warning       The end of a source line was encountered  before  the
               end of a character constant (') was encountered.  The
               indicated value was assumed.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the line.

3 NONTERMNULCHAR

 Message       Nonterminated   character   constant   contains    no
               characters;  '\0' assumed.

 Warning

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the constant.

3 NONTERMSTR

 Message       Nonterminated string constant;  quotes added  at  end
               of line.

 Warning

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the constant.

3 NOOPTIMIZATION

 Message       Complex  control  flow  caused  optimization  to   be
               suppressed for procedure or function "****".

 Informational Optimization was  not  performed  for  the  indicated
               function.

 User Action   None.

3 NOSTRDEF

 Message       "****" is a structure or union type that is not fully
               defined at this point in the compilation.

 Warning       You have used a structure or union  tag  at  a  point
               where its associated type is undefined, as in:

                    struct a a_var;
                       .
                       .
                    struct a 
                        {
                        int i;
                        float f;
                        };

 User Action   This usage is permitted,  but  not  recommended.   To
               suppress   the  message,  you  must  fully  define  a
               structure or union before you refer to its tag.

3 NOTDECL

 Message       "****" is not  declared  within  the  scope  of  this
               usage.

 Error         You have referred to an undeclared variable.   All  C
               variables  must be declared explicitly;  there are no
               defaults.

 User Action   Add an appropriate  declaration  for  the  referenced
               object.

3 NOTENUM

 Message       "****" is not an enum tag in this context.

 Warning       You have used an enum tag before the associated  type
               has been fully enumerated, as in:

                    enum color c1;
                       .
                       .
                    enum color { red,yellow };

 User Action   This usage is permitted,  but  not  recommended.   To
               avoid  the  message,  you must fully enumerate a type
               before you use its tag.

3 NOTFUNC

 Message       Function-valued expression not found.

 Error         An identifier  is  followed  by  parentheses  but  is
               neither a function name nor a dereferenced pointer to
               a function.

 User Action   Correct the expression.

3 NOTINTVAL

 Message       An integer value was not found where expected.

 Error         An integer value was not used where required.

 User Action   Check the indicated line carefully for missing  array
               subscripts  or  other references that require integer
               values.

3 NOTLVALUE

 Message       The target of a **** operator is not an lvalue.

 Error         The indicated operator, such as = (assignment)  or  &
               (address  of),  requires  an  lvalue for its operand,
               that is, an expression that could appear as the  left
               operand in an assignment.

 User Action   Replace the operand with a valid lvalue.

3 NOTPTRVAL

 Message       Address-valued expression not found.

 Error         The indicated  line  requires  a  unary  address  (*)
               operator  with  a nonpointer operand, or a nonpointer
               to the left of an arrow (->) operator.

 User Action   Correct the indicated line.

3 NOTSWITCH

 Message       Default labels and case labels valid only  in  switch
               statements.

 Error         You have used case or default as a label outside  the
               body of a switch statement.

 User Action   Change the offending label(s).

3 NOTUNIQUE

 Message       "****" is not a unique member name in this context.

 Error         The name of a structure or union member  is  used  in
               more than one structure or union, refers to different
               locations in its defining structures, and was used in
               a  reference to a structure in which was not defined.
               Thus, the name refers ambiguously to a place  in  the
               referenced structure.

 User Action   Refer to a structure or union only with a member name
               declared in it.

3 NOWORK

 Message       No source file found in command line.

 Fatal         You specified a CC command without a source file.

 User Action   Recompile.

3 NULCHARCON

 Message       Character  constant  contains  no  characters;   '\0'
               assumed.

 Warning       You have used '' for an ASCII NUL  character  instead
               of '\0'.

 User Action   This usage  is  permitted  but  unconventional.   Use
               '\0'.

3 NULHEXCON

 Message       Hexadecimal  constant  contains   no   digits;    0X0
               assumed.

 Warning       You have specified a constant such as 0X or 0x.

 User Action   Be sure that zero is a valid value in  this  context;
               if so, change the constant to 0x0.

3 PARMNOTUSED

 Message       Macro parameter  "****"  is  not  referenced  in  the
               definition.

 Warning       A macro definition has more parameters than appear in
               its substitution, as in:

                    #define m(a,b,c) a*b

 User Action   This is a possible programming  error.   Specify  the
               extra  parameter  in  the  substitution  or, if it is
               actually superfluous, delete it  from  the  parameter
               list.

3 PPUNEXPEOF

 Message       Unexpected end-of-file  encountered  in  preprocessor
               control line;  line ignored.

 Warning

 User Action   Examine the file to see whether the control  line  is
               necessary;  if so, correct the error and recompile.

3 PTRASSIGN

 Message       Assignment   to/from   pointers   and   integers   is
               nonportable.

 Warning       You have assigned an  integer  to  a  pointer  or  an
               address  to  an  integer  variable.   This message is
               issued only if /STANDARD=PORTABLE was specified.

 User Action   This usage is not portable and  is  not  recommended.
               The  only portable assignment is pointer = 0.  Change
               the operands or cast them to the same type.

3 PTRCOMPARE

 Message       Pointer comparison with nonzero integer  constant  or
               integer is a nonportable construct.

 Warning       You have compared a pointer's  value  with  something
               besides  the constant 0.  This message is issued only
               if /STANDARD=PORTABLE was specified.

 User Action   This usage is not portable and  is  not  recommended.
               The only portable comparison is of a pointer variable
               with 0.  Otherwise, avoid the message by changing the
               operands or casting them to the same type.

3 PTRFLOATCVT

 Message       The operand of  a  pointer  addition  or  subtraction
               operator was forced from floating point to integer.

 Warning       You  have  combined  a   pointer   operand   with   a
               floating-point value, as in:

                    int i,*ip;
                       .
                       .
                    i = ip + 2. ;

 User Action   To avoid the message, be sure that pointers are  used
               only  with  other  pointers or with integers;  in the
               above  example  and  similar  situations  remove  the
               decimal point from the literal constant.

3 QUALNOTLVALUE

 Message       The qualifier for "****" is not a valid lvalue.

 Error In a reference to a structure or union  member  accessed  via
               the  "."  operator,  the qualifying expression to the
               left of the "." must be an lvalue.

 User Action   Correct the qualifying expression.

3 REPOVERFLOW

 Message       Length of replacement  text  exceeds  maximum  buffer
               capacity;  "****" not substituted.

 Error         The length  of  the  replacement  text  for  a  macro
               reference, or the length of the text plus the rest of
               the line in which the reference occurs,  exceeds  the
               implementation's limit.

 User Action   Shorten the replacement text or use multiple substit-
               utions to achieve the desired result.

3 SEMICOLONADDED

 Message       Semicolon added at the end  of  the  previous  source
               line.

 Warning       A missing semicolon was added to the  line  prior  to
               the line numbered in this message.

 User Action   Check  the  previous  line  carefully  and  add   the
               semicolon in the appropriate place.

3 SYMTABOVFL

 Message       The total number of symbol table  pages  exceeds  the
               implementation's limit.

 Fatal         The program is too complex.

 User Action   Simplify the program by reducing the number and  size
               of  variables  and  other  names,  constants,  and so
               forth.

3 SYNTAXERROR

 Message       ********

 Error         The illustrated syntax error prevents the  generation
               of   an   object   file.   (There  are  no  important
               differences  between  the  conditions   causing   the
               various forms of the message.)

 User Action   Correct the errors shown.

3 TBLOVRFLW

 Message       Internal  table  overflow,   too   many   procedures,
               external  symbols  (psects),  or  the  program is too
               complex.

 Fatal         Either the source file contains too many functions or
               expressions,  or  the  compiler  has  overflowed  its
               virtual address space.

 User Action   Reduce the size of the source  file  by  dividing  it
               into  smaller, separately compilable files, or change
               the logic of the program  to  reduce  the  number  of
               complicated expressions.

3 TOOFEWARGS

 Message       Argument list  for  macro  "****"  contains  too  few
               arguments;  missing arguments assumed to be null.

 Warning       You have written a reference to the  indicated  macro
               with  fewer  arguments  than  are  specified  in  its
               definition.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the reference.

3 TOOMANYARGS

 Message       Argument list for  macro  "****"  contains  too  many
               arguments;  excess arguments ignored.

 Warning       You have written a reference to the  indicated  macro
               with   more  arguments  than  are  specified  in  its
               definition.

 User Action   To avoid  this  message  and  unpredictable  results,
               shorten the argument list.

3 TOOMANYCHAR

 Message       Character  constant  contains  too  many  characters;
               truncated to ****.

 Warning       The  length  of  a  character  constant  exceeds  the
               implementation limit (four characters).  The constant
               was truncated to the indicated value.

 User Action   Reduce the length of the character constant.

3 TOOMANYERR

 Message       The   total   number   of    errors    exceeds    the
               implementation's limit of 100.

 Fatal

 User Action   Correct the  errors  reported  in  previous  compiler
               messages and recompile.

3 TOOMANYINITS

 Message       The initializer list for "****"  specifies  too  many
               initializers;  excess initializers ignored.

 Warning       This message can be issued for any type of  variable.
               Some  causes  might be missing brackets from an array
               declaration, misplaced braces in an initializer  list
               that  would  cause  array  elements to be skipped, or
               simply, more initializers than elements in  an  array
               or structure.

 User Action   Check  the  declaration  and  make  the   appropriate
               corrections.

3 TOOMANYPARM

 Message       Too  many  macro   parameters;    excess   parameters
               ignored.

 Warning       The number of macro  parameters  in  a  #define  line
               exceeds the implementation limit of 64.

 User Action   Reduce the number of parameters.

3 TOOMANYSTR

 Message       String  constant  contains   too   many   characters;
               truncated.

 Warning       The character-string constant in  this  line  exceeds
               the implementation's limit of 1000 characters.

 User Action   Shorten the constant.

3 TRUNCFLT

 Message       Double-precision floating-point  constant  cannot  be
               converted to single precision;  0.0 assumed.

 Warning

 User Action   Ensure that zero is a valid value  in  this  context;
               if  necessary,  redeclare  the  conversion  target as
               double.

3 TRUNCSTRINIT

 Message       String initialization for "****"  contains  too  many
               characters to fit;  truncated.

 Warning       If the variable is a  simple  one-dimensional  array,
               the initializer is truncated (such that the length of
               the initializer is array-1)  and  the  null  byte  is
               added  to  the  end  of the array.  If the array is a
               multi-dimentional  array  or  an   array   within   a
               structure, the initializer is truncated to the length
               of the array and a null byte is not added.

 User Action   You should treat arrays  of  characters  as  strings,
               that is, allowing for the null byte at the end of the
               array.  The special case of multi-dimensional  arrays
               and  arrays  within  structures  should be taken into
               account, especially when you do  not  want  the  null
               byte to be truncated.

3 UABORT

 Message       Compilation terminated by user.

 Fatal         The  compilation  was  terminated  by  a  DCL  CTRL/C
               command.

 User Action   None.

3 UNDEFIFMAC

 Message       "****" is not a currently  defined  macro;   constant
               zero assumed.

 Warning       The identifier in a constant  expression  in  an  #if
               preprocessor control line is not currently defined as
               a macro.  The  expression  is  evaluated  as  if  the
               identifier were a constant zero.

 User Action   Define the  identifier  as  a  macro  or  remove  the
               reference to it.

3 UNDEFNAME

 Message       "****" is already undefined;  line ignored.

 Warning       The specified identifier  (in  an  #undef  line)  was
               either  never  defined or else occurred in a previous
               #undef.

 User Action   Remove the spurious #undef, or,  if  applicable,  add
               the  definition  of the identifier at the appropriate
               place.

3 UNEXPCTL

 Message       Unexpected  ****  control  line  encountered;    line
               ignored.

 Warning       The specified control line occurred out of place  and
               was ignored.

 User Action   Check the logic of all control lines in  the  program
               to be sure that it is valid.

3 UNEXPEND

 Message       Unexpected end-of-**** encountered in #define control
               line;  line ignored.

 Warning       The end of the #define line or end of the source file
               was encountered before the definition was complete.

 User Action   To avoid  this  message  and  unpredictable  results,
               correct the line.

3 UNEXPEOF

 Message       Unexpected end-of-file encountered in a ****.

 Error         The unexpected end-of-file prevents the generation of
               code.

 User Action   Correct the error and recompile.

3 UNRECCHAR

 Message       Unrecognized character ignored.

 Warning       The line  either  contains  an  entirely  meaningless
               character  or  one  that  appears  out  of its proper
               context, for example, a number sign (#) that  is  not
               the first character on a line.

 User Action   Move or remove the character.

3 WARNSUM

 Message       Completed with warnings.

 Warning       The compilation was completed,  but  several  warning
               messages   were  issued.   The  program  may  not  be
               logically correct.

 User Action   If the execution of the program does not produce  the
               expected  results,  correct  the statements for which
               warnings were issued.

2 Language_topics
 VAX-11 C language topics

3 Block
 A block is a compound statement.  It allows more than one statement
 to  appear where a single statement ordinarily is used.  It is made
 up of a list of declarations and statements, enclosed in braces:

     { [declaration ...] [statement ...] }

 The  declaration  list  is  optional;   if  it  is  included,   all
 declarations  of  variables  are  local  to the block and supersede
 previous declarations for the duration of the block.  Any  auto  or
 register  variables  are initialized each time the block is entered
 normally;  the initializations do not occur if the block is entered
 by a goto statement.  Blocks can be used wherever single statements
 are valid--for example, as the action clause of an if statement:

           if (i<1)
               { /* BEGINNING OF BLOCK */
               char c;
               for (c = 'a'; c <= 'z'; c++) printf("char = %c\n",c);
               }  /* END OF BLOCK */

3 Data_Types
 The data type of an object must be specified  in  its  declaration.
 The fundamental data types are the scalar types:

     int  32-bit signed integer
     unsigned 32-bit unsigned integer
     float single-precision floating-point number
     double double-precision number
     enum enumerated type
     char character

 The adjectives short and long can also be used to specify the  size
 of  the  object.   For  example,  a  short  int  is a 16-bit signed
 integer.  A long int is the same as an int in  VAX-11  C.   A  long
 float is the same as a double.

 The unsigned keyword can also be used as an adjective.  An unsigned
 short  or  unsigned  char  is  a  16-  or  8-bit  unsigned integer,
 respectively.

4 Array
 An array is an aggregate of subscripted elements of the same  type.
 Elements  of an array can have one of the fundamental data types or
 can  be  structures,  unions,  or  other  arrays  (multidimensional
 arrays).  An array is declared using square brackets.  For example:

      int array1[10];

 declares  array1  to  be  an  array  of  10  integers.   The  valid
 subscripts for array1 range from 0 to 9.  For another example:

      int array2[2][3];

 declares array2 to be a two-dimensional (2 by 3) array of integers.
 The elements are stored in row-major order:

      array2[0][0], array2[0][1], ...  array2[1][2].

4 enum
 Enumerated types are sets of scalar objects that have  type  names.
 Variables  are  declared with "enum-specifiers" in the place of the
 type specifier.  The forms of enum-specifier are:

      enum { enumerator,...  }
 or
      enum identifier { enumerator,...  }
 or
      enum identifier

 Each enumerator defines a constant of the  enumerated  type  (tag).
 The  enumerator  list  forms  an ordered list of the type's values.
 Each enumerator has the form "identifier [= expression]", where the
 "identifier"  is the name to be used for the constant value and the
 optional "expression" gives  its  integer  equivalent.   If  a  tag
 appears  but no list of enumerators, the enum-specifier refers to a
 previous definition of the enumerated type, identified by the tag.

4 Pointer
 A pointer in C is a variable that  holds  the  address  of  another
 variable.  Pointers are declared with the asterisk operator:

      int i,*ip,*np; /* i IS AN INTEGER, ip AND np ARE
        POINTERS TO INTEGERS */

 The following operations are permitted on pointers:

 o  Assigning an address to the pointer (as in ip = &i;)

 o  Fetching the pointed-to object (dereferencing) with the asterisk
    operator (i = *ip;, which assigns the addressed integer to i)

 o  Adding (as in ip += 5;, which makes ip point to the object  that
    is five longwords away from the initial address in ip)

 o  Subtracting (as in i = np -  ip;,  which  gives  the  number  of
    objects separating the objects pointed to by np and ip)


4 Structure
 A structure is an aggregate of members whose data types can differ.
 Members  can  be  scalar variables, arrays, structures, unions, and
 pointers to any object.  The size of a structure is the sum of  the
 sizes  of  its  members,  which  are  stored  in the order of their
 declarations.  Structures are  defined  with  the  keyword  struct,
 followed  by  an  optional tag, followed by a structure-declaration
 list in braces:

      struct [identifier] { struct-declaration ...  }

 Each struct-declaration is a type specifier (type  keyword,  struct
 tag,  union  tag,  enum tag, or typedef name) followed by a list of
 member declarators:

      type-specifier member-declarator,...  ;

 Each member declarator defines either an ordinary variable or a bit
 field:

      declarator
 or
      [declarator] :  constant-expression

4 typedef
 The keyword typedef is used  to  define  an  abbreviated  name,  or
 synonym,  for  a  lengthy type definition.  Grammatically, the word
 typedef is a storage-class specifier, so it can precede  any  valid
 declaration.   In  such  a  declaration, the identifiers name types
 instead of variables.  For example:

      typedef char CH, *CP, STRING[10],CF();

 In the scope of this declaration, CH is a synonym for  "character,"
 CP  for  "pointer  to  character,"  STRING for "10-element array of
 characters," and CF for "function returning a character."  Each  of
 the  type  definitions  can  be  used  in  that  scope  to  declare
 variables, as in:

      CF c; /* c IS A FUNCTION RETURNING A CHARACTER */
      STRING s; /* s IS A 10-CHARACTER STRING */

4 Union
 A union is an aggregate of members whose  data  types  can  differ.
 Members  can  be  scalar variables, arrays, structures, unions, and
 pointers to any object.  The size of a union is  the  size  of  its
 longest  member;   all its members occupy the same storage.  Unions
 are defined with the keyword union, followed by  an  optional  tag,
 followed by a union-declaration list in braces:

      union [identifier] { union-declaration ...  }

 Each union-declaration is a type specifier  (type  keyword,  struct
 tag,  union  tag,  enum tag, or typedef name) followed by a list of
 member declarators:

      type-specifier member-declarator,...  ;

 Each member declarator defines either an ordinary variable or a bit
 field:

      declarator
 or
      [declarator] :  constant-expression

3 Declarations
 Declarations specify the  function  calls,  labels,  and  variables
 referenced in the program.  Declarations in C have the form:

       declaration ::=
          decl-specifier ... [init-declarator,...] ;
       decl-specifier ::=
          type-specifier [decl-specifier,...]
          sc-specifier [decl-specifier,...]

 "decl-specifiers" give the  data  types  and,  optionally,  storage
 classes  of  the  declared  objects.   "init-declarators"  list the
 declared identifiers and, optionally, their initial values.

 For more information, see HELP CC Language_topics Data_types,  HELP
 CC Language_topics Storage_classes.

4 Interpretation
 The symbols used in declarations are C operators,  subject  to  the
 usual   rules   of  precedence  and  associativity.   In  order  of
 precedence, these  operators  are  parentheses  and  brackets,  for
 "function returning..." and "array of...", followed by the asterisk
 and sizeof (for "pointer to..." and "size of type or variable...").
 Parentheses  and  brackets  associate  left  to  right;  the others
 associate right to left.  Parentheses are also used to  change  the
 associativity of the other operators.  For example:

        char * ( *x() ) [];
             * ( *x() ) [] is char
               ( *x() ) [] is (pointer to) char
                 *x()      is (array of) (pointer to) char
                  x()      is (pointer to) (array of) (pointer to) 
                               char
                  x        is (function returning) (pointer to) 
                              (array of) (pointer to) char

 In this sort of breakdown, lower precedence operators  are  removed
 first.   With  two  equal  precedence  operators,  you  remove  the
 rightmost if they are left-to-right operators, and the leftmost  if
 they  are  right-to-left  operators.   For  instance,  "[]()" means
 "array of functions returning...."

3 Functions
 Functions consist of one or more blocks of statements that  perform
 one  logical  operation.   They  can be called from other functions
 either in the same program or in different  programs.   A  function
 may exchange values with the calling function.

 Function declarations have the form:

      function_name()
 or
      function_name(arg1,arg2,...)

 In the first form of the function declaration, the  function  takes
 no  arguments.   In  the second form, the function takes arguments.
 In  both  cases,  the  parenthesis  after  the  function  name  are
 required.

 VAX-11 C provides a library of common functions.   These  functions
 perform  standard  I/O  operations,  character and string handling,
 mathematical operations, miscellaneous system  services,  and  UNIX
 emulation.

 See also HELP CC Run-time_Functions.

3 Preprocessor
 The VAX-11 C  "preprocessor"  uses  control  lines  to  affect  the
 compilation of a source file.  In VAX-11 C, these control lines are
 processed by an early phase of the  compiler,  not  by  a  separate
 program.

 The preprocessor control lines begin with a number sign (#) and  do
 not end with a semicolon.  The number sign must appear in the first
 column of the listing.

4 Conditional_Compilation
 Conditional compilation is provided by the control lines:

 #if constant-expression
    Checks whether the constant expression is nonzero (true)

 #ifdef identifier
    Checks whether the identifier is defined

 #ifndef identifier
    Checks whether the identifier is undefined

 #else
    Introduces source lines to be compiled as an alternative to  the
    conditions tested by the above control lines

 #endif
    Ends the scope of the above control lines

 If the condition checked by #if, #ifdef, or #ifndef is  true,  then
 all  lines  between  the  #else  and  #endif  are  ignored.  If the
 condition is false, then any lines between the conditional  control
 line  and  the  #else  (or  if  there  is  no  #else,  between  the
 conditional and the #endif) are ignored.

4 #define
 The #define preprocessor control line has the form:

      #define identifier token-string

 The preprocessor substitutes the token  string  everywhere  in  the
 program  that  it  finds  the  identifier  except  within comments,
 character constants, or string constants.

 Macro replacements are defined in a #define  control  line  of  the
 form:

      #define name([parm1[,parm2,...]]) token-string

 Within the program, all macro references that have the form

      name([arg1[,arg2,...]])

 are replaced by the token  string.   The  arguments  in  the  macro
 reference replace the corresponding parameters in the token string.

4 #include
 The #include control line instructs the preprocessor to insert  the
 contents  of  the  specified  file  or  module  into  the  program.
 #Include control lines can have one of three forms:

      #include <filespec>
      #include "filespec"
      #include module-name

 Each form is interpreted differently by the compiler.  In the first
 form  (#include  <filespec>),  the  compiler  looks for the file in
 SYS$LIBRARY.   In  the  second  form  (#include  "filespec"),   the
 compiler  looks  for  the  file  in the device and directory of the
 source  file.   In  the  third  form  (#include  module-name),  the
 compiler  looks  first in the libraries specified in the CC command
 line.  If the module cannot be found, it looks  in  C$LIBRARY.   If
 the    module    still    cannot    be    found,    it   looks   in
 SYS$LIBRARY:CSYSDEF.TLB.

 In the first two forms, .H is the default file type.

 #Include control lines can be nested to four levels.

4 #line
 The #line control line applies a specified  line  number  and  file
 specification  to the next line of source text.  This can be useful
 for diagnostic messages.  The #line control line has the forms:

      #line constant identifier
      #line constant string
      # constant identifier
      # constant string

 The constant gives the line number to be applied to the  next  line
 of  source  text.   It  must  be  an nonsigned integer.  The second
 parameter supplies the file specification.   It  can  be  either  a
 VAX-11  C  identifier or a character-string constant (not to exceed
 128 characters).

4 #module
 The #module control line passes information about an object  module
 to the compiler.

 The #module control line can have one of two forms:

      #module identifier 
      #module identifier identifier
      #module identifier string

 The first parameter of the control line is a VAX-11  C  identifier.
 It  gives  the  name of the module.  The second parameter specifies
 the optional identification that appears on listings.  This may  be
 either a VAX-11 C identifier or a character-string constant with no
 more than 31 characters.

 There can be only one #module line per compilation.  It can  appear
 anywhere  before the C language text.  #Module lines are subject to
 token replacement by #define control lines.

4 #undef
 The  #undef  control  line  cancels  a  previously  defined   token
 replacement.   Any  other token replacements that occurred prior to
 the #undef control line remain.

 The #undef contol line has the form:

      #undef identifier

3 Statements
 Statements  are  the  executable  instructions  performed  by   the
 program.   Statements  produce  values and control program flow.  A
 group of statements enclosed in braces makes up a block.

 Any valid expression or declaration terminated by a  semi-colon  is
 considered  a  statement.  The statements that control program flow
 are described in further HELP frames.

 See  also  HELP  CC  Language_Topics  Declaration   and   HELP   CC
 Language_Topics Preprocessor.

4 break
 The break statement terminates the smallest  enclosing  while,  do,
 for,   or  switch  statement.   Control  passes  to  the  statement
 following the terminated statement.  The break  statement  has  the
 form:

      break ;

4 continue
 The continue statement  immediately  passes  control  to  the  test
 portion  of the smallest enclosing while, do, or for statement.  It
 has the form:

      continue ;

 In each of the following statements, a continue  is  equivalent  to
 "goto label;":

      while (expression) { statement ... label: ; }
      do { statement ... label: ; } while (expression);
      for (expression; expression; expression) { statement label: ;
      }

 Continue is not intended for switches.  A continue inside a  switch
 inside a loop causes reiteration of the loop.

4 do
 The do statement executes a statement one or more times, as long as
 a stated condition expression is true:

      do statement while ( expression ) ;

 The statement is always executed at least once.  The expression  is
 evaluated after each execution of the statement.  If the expression
 is not zero, the  statement  is  executed  again.   Note  that  the
 statement following the do keyword (the "body" of the do statement)
 is not optional;  the null statement (a lone semicolon) is provided
 for specifying a do statement with an empty body.

4 entry
 Although C has no entry statement, the word "entry"  is  a  keyword
 reserved for future use by DIGITAL.  It may not be used.

4 for
 The for statement executes a statement zero  or  more  times,  with
 three  specified  control  expressions.   Expression-1 is evaluated
 only once, before the first iteration;  expression-2  is  evaluated
 before  every  iteration;   expression-3  is  evaluated after every
 iteration  The  for  loop  terminates  if,   on   any   evaluation,
 expression-2 is zero.  The format of the for statement is:

      for ( [expression-1] ; [expression-2] ; [expression-3] )
          statement

 The for statement is equivalent to:

      expression-1;
      while ( expression-2 ) { statement expression-3; }

 Any of the three expressions can be omitted.   If  expression-2  is
 omitted, the "while" condition always is true.

4 goto
 The goto statement transfers control unconditionally to  a  labeled
 statement:

      goto identifier ;

 The identifier must be a label located  in  the  current  function.
 Goto may be used to branch into a block, but no initializations are
 performed on variables declared in the block.

4 if
 The if statement is a conditional statement.   It  can  be  written
 with or without an else clause:

      if ( expression ) statement
      if ( expression ) statement else statement

 In both cases, the expression is evaluated, and if it is not  zero,
 the  first  statement  is executed.  If the else clause is included
 and the  expression  is  zero,  the  statement  following  else  is
 executed instead.  In a series of if-else clauses, the else matches
 the most recent else-less if.

4 Labeled
 Any statement can be preceded by a label prefix of the form:

      identifier:

 which declares the identifier as a label.   The  scope  of  such  a
 declaration  is  the current function.  Labels are used only as the
 targets of goto statements.

4 Null
 A null statement is a semicolon:

      ;

 The null statement is used to provide a null action -- for example,
 the body of a for loop that takes no action:

      for(i=0; i < ARRAYSIZE && x[i] == 5; i++)
          ;

4 return
 The return statement causes a  return  from  a  function,  with  or
 without a return value:

      return ;
      return expression ;

 The return  value  is  undefined  if  not  specified  in  a  return
 statement.   If an expression is specified in the return statement,
 it is evaluated and the value is returned to the calling  function;
 the  value  is  converted, if necessary, to the type with which the
 called function was declared.  If a function does not have a return
 statement,  the effect (on reaching the end of the function) is the
 same  as  with  a  return  statement  that  does  not  specify   an
 expression.

4 switch
 The switch statement executes one or more of  a  series  of  cases,
 based on the value of an integer expression:

      switch ( expression ) body

 The switch's body typically is a block, within which any  statement
 can be prefixed with one or more case labels:

      case constant-expression :

 At most one statement in the body may have the label:

      default :

 The switch expression is evaluated and compared to the  cases.   If
 there  is  a  case matching the expression's value, it is executed;
 if not, the default case  is  executed.   The  switch  is  normally
 terminated  by  a  break,  return,  or goto statement in one of the
 cases.  If there is no matching case and no default,  the  body  of
 the switch statement is skipped.

4 while
 The while statement executes a statement zero  or  more  times,  as
 long as a stated condition is true:

      while ( expression ) statement

 The  expression  is  evaluated  before  each  execution,  and   the
 statement is executed if the expression is not zero.  Note that the
 statement following  the  parentheses  (the  "body"  of  the  while
 statement)  is not optional;  the null statement (a lone semicolon)
 is provided for specifying a while statement with an empty body.

3 Storage_classes
 The storage class of a variable  determines  when  its  storage  is
 allocated,  whether  its  contents  are  preserved across different
 blocks or functions, and what link-time scope the variable has.

 Auto variables are allocated at run time.  They are  not  preserved
 across  functions.  Auto is the default storage class for variables
 declared within a function.

 Extern variables are allocated at compile time.  They are preserved
 across  functions.   There  can be only 65,532 extern variables per
 program.   Extern  is  the  default  storage  class  for  variables
 declared outside a function.

 Globaldef, globalref, and globalvalue variables  are  allocated  at
 compile  time.  They are preserved across functions.  The number of
 global symbols is unlimited.

 Register variables are allocated  at  run  time.   They  cannot  be
 referenced from other separately compiled functions.

 Static variables are allocated at compile time.  They are preserved
 across  functions.  They cannot be referenced from other separately
 compiled functions.

2 Run-Time_Functions

3 abort
 Terminates the process.

 Synopsis:

      abort()

3 abs
 Returns the absolute value of an integer.

 Synopsis:

      int abs(integer)
      int integer;

3 access
 Checks a file to see if a specified access mode is allowed.

 Synopsis:

      int access(name,mode)
      char *name;
      int mode;

3 acos
 Returns a value in the range 0 to pi, which is the  arc  cosine  of
 the radian argument.

 Synopsis:

      #include math
      double acos(x)
      double x;

3 alarm
 Sends the signal SIGALRM to the invoking process after  the  number
 of seconds specified.

 Synopsis:

      int alarm(seconds)
      unsigned seconds;

3 asin
 Returns a value in the range -pi/2 to pi/2, which is the  arc  sine
 of its radian argument.

 Synopsis:

      #include math
      double asin(x)
      double x;

3 atan
 Returns a value in the range  -pi/2  to  pi/2,  which  is  the  arc
 tangent of its radian argument.

 Synopsis:

      #include math
      double atan(x)
      double x;

3 atan2
 Returns a value in the range  -pi/2  to  pi/2,  which  is  the  arc
 tangent of x/y, where x and y are the double arguments.

 Synopsis:

      #include math
      double atan2(x,y)
      double x,y;

3 atof
 Converts an ASCII string to a numeric value.  The ASCII string  has
 the form:

      [white-spaces][+|-]digits[.digits][e|E[+|-]integer]

 The first unrecognized character ends the  string.   This  function
 does not account for overflow resulting from the conversion.

 Synopsis:

      #include math
      double atof(nptr)
      char *nptr;

3 atoi
 Converts an ASCII string to a numeric value.  The ASCII string  has
 the form:

      [white-spaces][+|-]digits

 This function does not account  for  overflow  resulting  from  the
 conversion.

 atoi is the same as atol in VAX-11 C.

 Synopsis:

      int atoi(nptr)
      char *nptr;

3 atol
 Converts an ASCII string to a numeric value.  The ASCII string  has
 the form:

      [white-spaces][+|-]digits

 The function does not  account  for  overflow  resulting  from  the
 conversion.

 atol is the same as atoi in VAX-11 C.

 Synopsis:

      long atol(nptr)
      char *nptr;

3 brk
 brk defines the break for the current image process and returns the
 old break value.

 Synopsis:

      char *brk(addr)
      unsigned addr;

3 cabs
 Returns sqrt(x*x + y*y).

 Synopsis:

      #include math
      double cabs(z)
      struct
          {
          double x;
          double y;
          } z;

3 calloc
 Allocates space for an area in memory.

 Synopsis:

      char *calloc(number,size)
      unsigned number,size;

3 ceil
 Returns the smallest integer (as a double)  that  is  equal  to  or
 greater than its argument.

 Synopsis:

      #include math
      double ceil(x)
      double x;

3 cfree
 Deallocates the area  allocated  by  calloc,  malloc,  or  realloc.
 Traditionally,  cfree  is  used  with  calloc;   free  is used with
 malloc.  However, in VAX-11 C, the cfree and free functions are the
 same.

 Synopsis:

      int cfree(pointer)
      char *pointer;

3 chdir
 Changes the default directory.

 Synopsis:

      int chdir(name)
      char *name;

3 chmod
 Changes a file protection.

 Synopsis:

      int chmod(name,mode)
      char *name;
      unsigned mode;

3 chown
 Changes the owner UIC of a file.

 Synopsis:

      int chown(name,owner,group)
      char *name;
      unsigned owner,group;

3 clearerr
 Resets the error and end-of-file indicators for a file.

 Synopsis:

      #include stdio
      ferror(file_pointer)
      FILE *file_pointer;

3 close
 Closes a file;  used with open and creat.

 Synopsis:

      int close(file_descriptor)
      int file_descriptor;

3 cos
 Returns the cosine of its radian argument.

 Synopsis:

      #include math
      double cos(x)
      double x;

3 cosh
 Returns the hyperbolic cosine of its argument.

 Synopsis:

      #include math
      double cosh(x)
      double x;

3 creat
 Creates or prepares to rewrite a file by file descriptor.

 Synopsis:

      int creat(name,mode[,file_attribute,...])
      char *name, *file_attribute;
      unsigned mode;

3 ctermid
 Returns the name of the controlling terminal.

 Synopsis:

      #include stdio
      char *ctermid(string)
      char *string;

3 ctime
 Converts the time in seconds to the form:

      wkd mmm dd hh:mm:ss 19yy\n\0

 Synopsis:

      #include time
      char *ctime(bintim)
      long *bintim;

3 cuserid
 Returns the name of the user who initiated the current process.

 Synopsis:

      #include stdio
      char *cuserid(string)
      char *string;

3 delete
 Deletes a file by  file  specification.   The  delete  function  is
 unique to VAX-11 C.

 Synopsis:

      int delete(file_specification)
      char *file_specification;

3 dup
 Creates a new file descriptor for an existing file.

 Synopsis:

      int dup(file_descriptor)
      int file_descriptor;

3 dup2
 Makes   file_descriptor_2   point   to    the    same    file    as
 file_descriptor_1.

 Synopsis:

      int dup2(file_descriptor_1, file_descriptor_2)
      int file_descriptor_1, file_descriptor_2;

3 ecvt
 Converts a double value to a NUL-terminated string of ASCII  digits
 and returns the address of the string.

 Synopsis:

      char *ecvt(value,ndigit,decpt,sign);
      double value;
      int ndigit,*decpt,*sign;

3 execl
 Executes the image in the named file.  execl's  arguments  are  the
 file  name and character strings giving the arguments to the called
 image.  The argument list must end with 0.

 Synopsis:

      int execl(name,arg0,arg1,...,0)
      char *name,*arg0,...*argn;

3 execv
 Executes the image in the named file.  execv's  arguments  are  the
 name  of  the  file and an array of strings giving the arguments to
 the called image.  The last element of the array must be 0.

 Synopsis:

      int execv(name,argv)
      char *name,argv[];

3 execle
 Executes the image in the named file.  execle's arguments  are  the
 name  of  the  file, character strings containing the arguments for
 the called  image,  and  an  array  of  strings  that  specify  the
 program's  environment.   The strings in the environment array have
 the form:

      HOME  the user's login directory
      TERM  the type of the terminal
      PATH  the default device and directory
      USER  the name of the user initiating the current process

 The strings for the environment array can  be  retrieved  with  the
 getenv function.

 Synopsis:

      int execle(name,arg0,arg1,...argn,0,envp)
      char *name, *arg0,*arg1,...,*argn,*envp[];

3 execve
 Executes the image in the named file.  The arguments to execve  are
 the  file name, an array of strings containing the arguments to the
 called image,  and  an  environment  array.   The  strings  in  the
 environment array have the form:

      HOME  the user's login directory
      TERM  the type of the terminal
      PATH  the default device and directory
      USER  the name of the user initiating the current process

 The strings for the environment array can  be  retrieved  with  the
 getenv function.

 Synopsis:

      int execve(name,argv,envp)
      char *name,*argv[],*envp[];

3 exit
 Terminate the calling process.  exit flushes and  closes  all  open
 files before terminating the process;  _exit does not.

 Synopses:

      exit(status)
      int status;
      _exit(status)
      int status;

3 exp
 Returns the base e raised to the power of the argument.

 Synopsis:

      #include math
      double exp(x)
      double x;

3 fabs
 Returns the absolute value of a floating-point value.

 Synopsis:

      #include math
      double fabs(x)
      double x;

3 fclose
 Closes a file;  used with fopen.

 Synopsis:

      #include stdio
      int fclose(file_pointer)
      FILE *file_pointer;

3 fcvt
 Converts a double value to a NUL-terminated string of ASCII  digits
 and returns the address of the string.

 Synopsis:

      char *fcvt(value,ndigit,decpt,sign)
      double value;
      int ndigit,*decpt,*sign;

3 fdopen
 Associates a file pointer with a file descriptor.

 Synopsis:

      FILE *fdopen(file_descriptor,type)
      int file_descriptor;
      char *type;


 Types are  "r"  (read),  "w"  (write),  "a"  (append),  "r+"  (read
 update), "w+" (write update), and "a+" (append update).

3 feof
 Tests for end-of-file.

 Synopsis:

      #include stdio
      int feof(file_pointer)
      FILE *file_pointer;

3 ferror
 Indicates if an error occurred during a read or write of the file.

 Synopsis:

      #include stdio
      int ferror(file_pointer)
      FILE *file_pointer;

3 fflush
 Writes out any buffered information to the file.

 Synopsis:

      #include stdio
      int fflush(file_pointer)
      FILE *file_pointer;

3 fgetc
 Returns the next character from the file.  getc is implemented as a
 macro.  fgetc generates a function call.

 Synopsis:

      #include stdio
      int fgetc(file_pointer)
      FILE *file_pointer;

3 fgetname
 Returns  the  VAX/VMS  file  specification  associated   with   the
 specified  file pointer.  The fgetname function is unique to VAX-11
 C.

 Synopsis:

      #include stdio
      char *fgetname(file_pointer,buffer)
      FILE *file_pointer;
      char *buffer;

3 fgets
 Reads a line from a file until it reads either  a  newline  or  the
 specified  maximum  number of characters.  fget terminates the line
 with a NUL character.

 Synopsis:

      #include stdio
      char *fgets(string,maxline,file_pointer)
      char *string;
      int maxline;
      FILE *file_pointer;

3 fileno
 Returns an integer file descriptor.

 Synopsis:

      #include stdio
      int fileno(file_pointer)
      FILE *file_pointer;

3 floor
 Returns (as a double) the largest integer  that  is  less  than  or
 equal to its argument.

 Synopsis:

      #include math
      double floor(x)
      double x;

3 fopen
 Opens a file by file pointer.

 Synopsis:

      #include stdio
      FILE *fopen(file_spec, mode)
      char *file_spec, *mode;


 Modes are:  "r" (read),  "w"  (write),  "a"  (append),  "r+"  (read
 update), "w+" (write update), and "a+" (append update).

3 fprintf
 Performs formatted output to a specified file.

 Synopsis:

      #include stdio
      int fprintf(pointer,format[,output_source,...])
      FILE *pointer;
      char *format;


 A format specification is a character string that states the output
 format.   The  string  may  contain  ordinary  characters which are
 simply  copied  to  the  output,  or  it  may  contain   a   format
 specification.   Format  specifications  begin  with a percent sign
 (%), and end with a conversion character  that  states  the  output
 format.   Each  format  specification must be paired with an output
 source.  Format specifications are matched  to  output  sources  in
 left-to-right order.

4 Conversion_Characters

  d   Convert to decimal format
  o   Convert to unsigned octal format
  x   Convert to unsigned hexadecimal format
  u   Convert to unsigned decimal format
  c   Output a single non-NUL character
  s   Output a string of characters
  e   Convert float or double to the format
      [-]m.nnnnnnE[+|-]xx
  f   Convert float or double to the format [-]m.nnnnnn
  g   Convert float or double to the shortest format
      of d, e, or f.
  l   Used with d, o, x, or u, specifies the corresponding
      long integer.
  %   Write out the percent symbol

3 fputc
 Write a character to a file.

 Synopsis:

      #include stdio
      int fputc(character,file_pointer)
      char character;
      FILE *file_pointer;

3 fputs
 Writes a character string to a file.

 Synopsis:

      #include stdio
      int fputs(string,file_pointer)
      char *string;
      FILE *file_pointer;

3 fread
 Reads a specified number of items from a file.

 Synopsis:

      #include stdio
      int fread(pointer,sizeof(*pointer),nitems,file_pointer)
      char *pointer;
      int nitems;
      FILE *file_pointer;

3 free
 Deallocates the area  allocated  by  calloc,  malloc,  or  realloc.
 Traditionally,  free  is  used  with  malloc and cfree is used with
 calloc.  However, in VAX-11 C, the free and cfree functions are the
 same.

 Synopsis:

      int free(pointer)
      char *pointer;

3 freopen
 Reassigns the address of a file pointer and opens the file.

 Synopsis:

      #include stdio
      FILE *freopen(file_spec,access_mode,file_pointer)
      char *file_spec,*access_mode;
      FILE *file_pointer;

3 frexp
 Returns the mantissa of a  double  value.   The  mantissa  is  also
 double and its magnitude is less than 1.

 Synopsis:

      #include math
      double frexp(value,eptr)
      double value;
      int eptr;

3 fscanf
 Performs formatted input from a file.

 Synopsis:

      #include stdio
      fscanf(file_pointer,format,[,input_pointer...])
      FILE *file_pointer;
      char *format;

 Format specifications begin with a percent sign (%) followed  by  a
 conversion character and a number indicating the size of the field.

4 Conversion_Characters
 d           Decimal integer
 D           Decimal long integer
 o           Octal integer
 O           Octal long integer
 x           Hexadecimal integer
 X           Hexadeciml long integer
 hd, ho, hx  Short integer of the specified radix
 c           Single character
 s           Character string
 e,f         Floating-point number having the form:
             [+|-]nnn[.[ddd]][[E|e][+|-]nn]
 E,F         Double-precision e and f
 ld, lo, lx  Long decimal, long octal, and long hexadecimal integer
 le, lf      Double-precision e and f
 [..]        Brackets enclosing a set of  characters.   The  set  is
             made  up of the characters in the string field.  If the
             first character is an up-arrow (^), the set is made  up
             of the delimiters for the field.

3 fseek
 Positions to a specified byte offset from either the  beginning  of
 the file or from the current location within the file.

 Synopsis:

      #include stdio
      int fseek(file_pointer,offset,direction)
      FILE *file_pointer;
      int offset, direction;

3 ftell
 Returns the byte offset from the  beginning  of  the  file  to  the
 current location within the file.

 Synopsis:

      #include stdio
      int ftell(file_pointer)
      FILE *file_pointer;

3 ftime
 Returns the time elasped on the system since  00:00:00  January  1,
 1970.

 Synopsis:

      #include timeb
      ftime(time_pointer)
      struct timeb *time_pointer;


 The time_b structure contains the  members  time_t  time,  unsigned
 short millitm, short timezone, and short dstflag.

3 fwrite
 Appends the specified number of items to the file.

 Synopsis:

      #include stdio
      int fwrite(pointer,sizeof(*pointer),nitems,file_pointer)
      char *pointer;
      int nitems;
      FILE *file_pointer;

3 gcvt
 Converts a double value to a NUL-terminated string of ASCII  digits
 and returns the address of the string.

 Synopsis:

      char *gcvt(value,ndigit,buf)
      double value;
      char *buf;
      int ndigit;

3 getc
 Returns the next character from the file.  getc is implemented as a
 macro.  fgetc generates a function call.

 Synopsis:

      #include stdio
      int getc(file_pointer)
      FILE *file_pointer;

3 getchar
 Returns the next character from the standard input device.

 Synopsis:

      #include stdio
      int getchar();

3 getegid
 Returns the group number from the user identification code.

 Synopsis:

      unsigned getegid()

3 getenv
 Searches the environment array and  returns  the  value  associated
 with the environment name.  The names can be one of the following:

      HOME  user's login directory
      TERM  terminal type
      PATH  default device and directory
      USER  name of the user initiating the process

 Synopsis:

      char *getenv(name)
      char *name;

3 geteuid
 Returns the member number from the user identification code.

 Synopsis:

      unsigned geteuid()

3 getgid
 Returns the group number from the user identification code.

 Synopsis:

      unsigned getgid()

3 getname
 Returns the VAX/VMS file specification associated with the  integer
 file descriptor.  The getname function is unique to VAX-11 C.

 Synopsis:

      char *getname(file_descriptor,buffer)
      int file_descriptor;
      char *buffer;

3 getpid
 Returns the current process ID.

 Synopsis:

      int getpid()

3 gets
 Reads  a  line  from  the  standard  input  device.   The   newline
 terminator is replaced with the ASCII NUL character.

 Synopsis:

      char *gets(string)
      char *string;

3 getuid
 Returns the member number from the user identification code.

 Synopsis:

      unsigned getuid()

3 getw
 Returns the next four characters from the file as an integer.

 Synopsis:

      #include stdio
      int getw(file_pointer)
      FILE *file_pointer;

3 gsignal
 Raises a specified software signal.

 Synopsis:

      #include signal
      int gsignal(sig)
      int sig;

3 hypot
 Returns sqrt(x*x + y*y).

 Synopsis:

      #include math
      double hypot(x,y)
      double x,y;

3 isalnum
 Returns an nonzero integer if the character is alphanumeric.

 Synopsis:

      #include ctype
      int isalnum(character)
      char character;

3 isalpha
 Returns a nonzero integer if the character is alphabetic.

 Synopsis:

      #include ctype
      int isalpha(character)
      char character;

3 isascii
 Returns a nonzero integer if the character is ASCII.

 Synopsis:

      #include ctype
      int isascii(character)
      char character;

3 isatty
 Returns 1 if the file descriptor is associated with a  terminal,  0
 if it is not.

 Synopsis:

      int isatty(file_descriptor)
      int file_descriptor;

3 iscntrl
 Returns a nonzero integer if the  character  is  an  ASCII  DEL  or
 nonprinting character.

 Synopsis:

      #include ctype
      int iscntrl(character)
      char character;

3 isdigit
 Returns a nonzero integer if the character is a digit.

 Synopsis:

      #include ctype
      int isdigit(character)
      char character;

3 isgraph
 Returns a nonzero integer if the  character  is  an  ASCII  graphic
 character.

 Synopsis:

      #include ctype
      int isgraph(character)
      char character;

3 islower
 Returns a nonzero integer if the character is lowercase.

 Synopsis:

      #include ctype
      int islower(character)
      char character;

3 isprint
 Returns a nonzero integer if the character  is  an  ASCII  printing
 character.

 Synopsis:

      #include ctype
      int isprint(character)
      char character;

3 ispunct
 Returns a nonzero integer if the character is an ASCII  punctuation
 character.

 Synopsis:

      #include ctype
      int ispunct(character)
      char character;

3 isspace
 Returns a nonzero integer if  the  character  is  an  ASCII  space,
 horizontal or vertical tab, carriage return, form feed, or newline.

 Synopsis:

      #include ctype
      int isspace(character)
      char character;

3 isupper
 Returns a nonzero integer if the character is uppercase.

 Synopsis:

      #include ctype
      int isupper(character)
      char character;

3 isxdigit
 Returns a nonzero integer if the character is a hexadecimal digit.

 Synopsis:

      #include ctype
      int isxdigit(character)
      char character;

3 kill
 Sends a signal to a process.

 Synopsis:

      int kill(pid,sig)
      int pid,sig;

3 ldexp
 Returns its first argument times 2  to  the  power  of  its  second
 argument.

 Synopsis:

      #include math
      double ldexp(value,e)
      double value;
      int e;

3 localtime
 Converts a time in seconds into  hours,  minutes,  seconds,  month,
 day, day of the month, year, day of the week, and day of the year.

 Synopsis:

      #include time
      struct tm *localtime(bintim)
      int *bintim;

3 log
 Returns the natural (base-e) logarithm of its argument.

 Synopsis:

      #include math
      double log(x)
      double x;

3 log10
 Returns the base-10 logarithm of its argument.

 Synopsis:

      #include math
      double log10(x)
      double x;

3 longjmp
 Restores the register context of  the  environment  buffer  of  its
 associated setjmp call.

 Synopsis:

      #include setjmp
      longjmp(env,val)
      jmp_buf env;

3 lseek
 Positions to a byte offset  within  a  file  and  returns  the  new
 position  as  an  integer.  The new position can be from either the
 beginning of  the  file  (direction  =  0),  the  current  position
 (direction = 1), or the end-of-file (direction = 2).

 Synopsis:

      int lseek(file_descriptor,offset,direction)
      int offset;
      int file_descriptor,direction;

3 malloc
 Allocates an area of contiguous memory.

 Synopsis:

      char *malloc(size)
      unsigned size;

3 mktemp
 Creates a unique file name from a template which you  supply.   The
 template  has  the  form:   "namXXXXXX".  The X's are replaced by a
 unique series of characters;  "nam" is optional.

 Synopsis:

      char *mktemp(template)
      char *template;

3 modf
 Returns the positive fractional part  of  its  first  argument  and
 assigns the address of the integral part to its second argument.

 Synopsis:

      #include math
      double modf(value,iptr)
      double value,iptr;

3 nice
 Increases or decreases a process priority.

 Synopsis:

      nice(increment)
      int increment;

3 open
 Opens a file  for  reading  (mode=0),  writing  (mode=1),  or  both
 (mode=2).

 Synopsis:

      int open(name, mode)
      char *name;
      int mode;

3 pause
 Stops the calling process until it receives a signal.

 Synopsis:

      pause()

3 perror
 Writes  a  short  message  to  stderr  describing  the  last  error
 encountered during a call to the operating system.

 Synopsis:

      extern char *sys_errlist[];
      extern int sys_nerr;

      perror(string)
      char *string;

3 pipe
 Allows two child processes to share data with read and write calls.

 Synopsis:

      int pipe(file_descriptor)
      int file_descriptor[2];

3 pow
 Returns the first argument  raised  to  the  power  of  the  second
 argument.

 Synopsis:

      #include math
      double pow(x,y)
      double x,y;

3 printf
 Performs formatted output to the standard output device.

 Synopsis:

      int printf(format_specification[,output_source,...])
      char *format_specification;


 A format specification is a character string that states the output
 format.   The  string  may  contain  ordinary  characters which are
 simply  copied  to  the  output,  or  it  may  contain   a   format
 specification.   Format  specifications  begin  with a percent sign
 (%), and end with a conversion character  that  states  the  output
 format.   Each  format  specification must be paired with an output
 source.  Format specifications are matched  to  output  sources  in
 left-to-right order.

4 Conversion_Characters

  d   Convert to decimal format
  o   Convert to unsigned octal format
  x   Convert to unsigned hexadecimal format
  u   Convert to unsigned decimal format
  c   Output a single non-NUL character
  s   Output a string of characters
  e   Convert float or double to the format
      [-]m.nnnnnnE[+|-]xx
  f   Convert float or double to the format [-]m.nnnnnn
  g   Convert float or double to the shortest format
      of d, e, or f.
  l   Used with d, o, x, or u, specifies the corresponding
      long integer.
  %   Write out the percent symbol

3 putc
 Writes a character to a file.

 Synopsis:

      #include stdio
      int putc(character,file_pointer)
      char character;
      FILE *file_pointer;

3 putchar
 Writes a character to the standard output device.

 Synopsis:

      #include stdio
      int putchar(character)
      char character;

3 puts
 Writes a NUL-terminated string followed by a  \n  to  the  standard
 output device.

 Synopsis:

      int puts(string)
      char *string;

3 putw
 Writes the next four character to a file as an integer.

 Synopsis:

      #include stdio
      int putw(integer,file_pointer)
      int integer;
      FILE *file_pointer;

3 rand
 Returns pseudorandom numbers in the range 0 to (2**31-1).

 Synopsis:

      int rand();

3 read
 Reads a specified numbers of bytes from a file and places them in a
 buffer.

 Synopsis:

      int read(file_descriptor,buffer,nbytes)
      int file_descriptor,nbytes;
      char *buffer;

3 realloc
 Changes the size of an area  in  memory  by  the  number  of  bytes
 specified.

 Synopsis:

      char *realloc(pointer,size)
      char *pointer;
      unsigned size;

3 rewind
 Positions to the beginning of the file.

 Synopsis:

      #include stdio
      int rewind(file_pointer)
      FILE *file_pointer;

3 sbrk
 Adds a (positive or negative) number of bytes to the current  break
 and returns the old break value.

 Synopsis:

      char *sbrk(incr)
      unsigned incr;

3 scanf
 Performs formatted input from the standard input device.

 Synopsis:

      int scanf(format[,input_pointer...])
      char *format;


 Format specifications begin with a percent sign (%) followed  by  a
 conversion character and a number indicating the size of the field.

4 Conversion_Characters
 d           Decimal integer
 D           Decimal long integer
 o           Octal integer
 O           Octal long integer
 x           Hexadecimal integer
 X           Hexadeciml long integer
 hd, ho, hx  Short integer of the specified radix
 c           Single character
 s           Character string
 e,f         Floating-point number having the form:
             [+|-]nnn[.[ddd]][[E|e][+|-]nn]
 E,F         Double-precision e and f
 ld, lo, lx  Long decimal, long octal, and long hexadecimal integer
 le, lf      Double-precision e and f
 [..]        Brackets enclosing a set of  characters.   The  set  is
             made  up of the characters in the string field.  If the
             first character is an up-arrow (^), the set is made  up
             of the delimiters for the field.

3 setbuf
 Associates a buffer with an input or output file.

 Synopsis:

      #include stdio
      setbuf(file_pointer, buffer)
      FILE *file_pointer;
      char *buffer;

3 setgid
 Included for compatability;  no operation performed.

 Synopsis:

      int setgid(group_number)
      unsigned group_number;

3 setjmp
 Saves the register context of the calline function for a subsequent
 longjmp call.

 Synopsis:

      #include setjmp
      setjmp(env)
      jmp_buf env;

3 setuid
 Included for compatability;  no operation performed.

 Synopsis:

      int setuid(member_number)
      unsigned member_number;

3 signal
 Allows you to either catch or ignore a signal.

 Synopsis:

      #include signal
      int (*signal(sig,func))()
      int sig;
      int (*func)();

3 sin
 Returns a double value that is the sine of its radian argument.

 Synopsis:

      #include math
      double sin(x)
      double x;

3 sinh
 Returns the hyperbolic sine of its argument.

 Synopsis:

      #include math
      double sinh(x)
      double x;

3 sleep
 Suspends the current process for at least the specified  number  of
 seconds.

 Synopsis:

      int sleep(seconds)
      unsigned seconds;

3 sprintf
 Performs formatted output to a character string in memory.

 Synopsis:

      int sprintf(string,format[,output_source,...])
      char *string, *format;


 A format specification is a character string that states the output
 format.   The  string  may  contain  ordinary  characters which are
 simply  copied  to  the  output,  or  it  may  contain   a   format
 specification.   Format  specifications  begin  with a percent sign
 (%), and end with a conversion character  that  states  the  output
 format.   Each  format  specification must be paired with an output
 source.  Format specifications are matched  to  output  sources  in
 left-to-right order.

4 Conversion_Characters

  d   Convert to decimal format
  o   Convert to unsigned octal format
  x   Convert to unsigned hexadecimal format
  u   Convert to unsigned decimal format
  c   Output a single non-NUL character
  s   Output a string of characters
  e   Convert float or double to the format
      [-]m.nnnnnnE[+|-]xx
  f   Convert float or double to the format [-]m.nnnnnn
  g   Convert float or double to the shortest format
      of d, e, or f.
  l   Used with d, o, x, or u, specifies the corresponding
      long integer.
  %   Write out the percent symbol

3 sqrt
 Returns the square root of its argument.

 Synopsis:

      #include math
      double sqrt(x)
      double x;

3 srand
 Reinitializes the random number generator when the  argument  1  is
 used, or sets it to a specific point with any other number.

 Synopsis:

      int srand(seed)
      int seed;

3 sscanf
 Performs formatted input from a character  string  in  memory.   .b
 Synopsis:

      #include stdio
      sscanf(string,format[,input_pointer...])
      char *string,*format;


 Format specifications begin with a percent sign (%) followed  by  a
 conversion character and a number indicating the size of the field.

4 Conversion_Characters
 d           Decimal integer
 D           Decimal long integer
 o           Octal integer
 O           Octal long integer
 x           Hexadecimal integer
 X           Hexadeciml long integer
 hd, ho, hx  Short integer of the specified radix
 c           Single character
 s           Character string
 e,f         Floating-point number having the form:
             [+|-]nnn[.[ddd]][[E|e][+|-]nn]
 E,F         Double-precision e and f
 ld, lo, lx  Long decimal, long octal, and long hexadecimal integer
 le, lf      Double-precision e and f
 [..]        Brackets enclosing a set of  characters.   The  set  is
             made  up of the characters in the string field.  If the
             first character is an up-arrow (^), the set is made  up
             of the delimiters for the field.

3 ssignal
 Establishes the action to take when a specific signal is raised.

 Synopsis:

      #include signal
      int (*ssignal(sig,action))()
      int sig, (*action)();

3 strcat
 Concatenates strings.  strcat terminates  the  concatenated  string
 with a NUL.

 Synopsis:

      char *strcat(string_1,string_2)
      char *string_1,*string_2;

3 strchr
 strchr returns the address of  the  first  occurrence  of  a  given
 character in a NUL-terminated string.

 Synopsis:

      char *strchr(string,character)
      char *string,character;

3 strcmp
 strcmp compares two strings and indicates whether the first  string
 is  lexicographically  less  than,  equal  to,  or greater than the
 second string.

 Synopsis:

      int strcmp(string_1,string_2)
      char *string_1,*string_2;

3 strcpy
 strcpy copies string_2 to string_1, stopping after  string_2's  NUL
 terminator is copied.

 Synopsis:

      char *strcpy(string_1,string_2)
      char *string_1,*string_2

3 strcspn
 Searches a string for the occurrence of a character in  a  set  and
 returns   the   number  of  characters  that  precede  the  matched
 character.

 Synopsis:

      int strcspn(string,charset)
      char *string,*charset;

3 strlen
 Returns the length of  an  ASCII  string,  not  including  the  NUL
 terminator.

 Synopsis:

      int strlen(string)
      char *string;

3 strncat
 strncat concatenates the  second  string  to  the  first  up  to  a
 specified maximum or until NUL is encountered.

 Synopsis:

      char *strncat(string_1,string_2,max)
      char *string_1,*string_2;
      int max;

3 strncmp
 strncmp comparison up to a maximum number of characters in the  two
 strings and returns a value to indicate whether the first string is
 less than, equal to, or greater than the second string.

 Synopsis:

      int strncmp(string_1,string_2,max)
      char *string_1,*string_2;
      int max;

3 strncpy)
 strncpy copies a specified number of characters  from  string_2  to
 string_1   either  truncating  string_2  or  padding  it  with  NUL
 characters.

 Synopsis:

      char *strncpy(string_1,string_2,max)
      char *string_1,*string_2;
      int max;

3 strpbrk
 Searches a string for the occurrence of a character  within  a  set
 and returns the first character in the string that is in the set.

 Synopsis:

      char *strpbrk(string,charset)
      char *string,*charset;

3 strrchr
 Returns the address of the last occurrence of a given character  in
 a string.

 Synopsis:

      char *strrchr(string,character)
      char *string,character;

3 strspn
 Searches a string for the first occurrence of a character  that  is
 not  in  a  set  of characters and returns the number of characters
 that preceded the mismatched character.

 Synopsis:

      int strspn(string,charset)
      char *string,*charset;

3 tan
 Returns the tangent of its radian argument.

 Synopsis:

      #include math
      double tan(x)
      double x;

3 tanh
 Returns the hyperbolic tangent of its argument.

 Synopsis:

      #include math
      double tanh(x)
      double x;

3 time
 Returns the time elasped on the system since  00:00:00  January  1,
 1970.

 Synopsis:

      long time(time_location)
      long *time_location;

3 times
 Returns the accumulated times of the current  process  and  of  its
 terminated child processes to the following buffer:

      struct tbuffer
          {
          int proc_user_time;
          int proc_system_time;
          int child_user_time;
          int child_system_time;
          };

 Synopsis

      times(buffer)
      struct tbuffer *buffer;

3 tmpfile
 Creates a temporary file.

 Synopsis:

      #include stdio
      FILE *tmpfile()

3 tmpnam
 Creates a character string that can be used in place  of  the  file
 name argument in other function calls.

 Synopsis:

      #include stdio
      char *tmpnam(name)
      char *name;

3 toascii
 Converts an 8-bit ASCII character to a 7-bit ASCII character.

 Synopsis:

      #include ctype
      int toascii(character)
      char character;

3 tolower
 Converts an  uppercase  letter  to  lowercase;   returns  lowercase
 letters  unchanged.   tolower  is  a  true function;  _tolower is a
 macro.

 Synopses:

      char tolower(character)
      char character;

      #include ctype
      char _tolower(character)
      char character;

3 toupper
 Converts lowercase letters to uppercase, returns uppercase  letters
 unchanged.  toupper is a true function;  _toupper is a macro.

 Synopses:

      char toupper(character)
      char character;

      #include ctype
      char _toupper(character)
      char character;

3 umask
 Creates a file protection mask.

 Synopsis:

      int umask(mode_complement)
      unsigned mode_complement;

3 ungetc
 Writes a character to the buffer and  leaves  the  file  positioned
 before the character.

 Synopsis:

      #include stdio
      int ungetc(character,file_pointer)
      char character;
      FILE *file_pointer;

3 vfork
 Sets up the communication channels for spawning and  controlling  a
 new (child) process.

 Synopsis:

      int vfork()

3 wait
 Suspends the calling process until either a signal is  received  or
 until a child process terminates.

 Synopsis:

      int wait(status)
      int *status;

3 write
 Writes a number of bytes to a file.

 Synopsis:

      int write(file_descriptor,buffer,nbytes)
      int file_descriptor,nbytes;
      char *buffer;

2 Release_Notes
 Release Notes for VAX C.
3 V1_5
 This is VAX C Version 1.5-89.

 The file SYS$LIBRARY:VAXCSPR.DAT lists the  SPRs  that  were  fixed
 during  V1.5  development.   TYPE or PRINT this file for a complete
 list of changes to VAX C.

 The   other   release   notes   document   restrictions,    correct
 documentation  errors,  or  clarify  issues that are not adequately
 documented elsewhere.

4 Exec_changes
 The VAX C  run-time  library  provides  functions  that  allow  the
 programmer  to  create  subprocesses  from  a  VAX  C program.  The
 creating process is called the "parent" and the created  subprocess
 is called the "child."

 The parent process can execute VAX  C  programs  in  its  children,
 either  synchronously  or  asynchronously.   The number of children
 that can run  simultaneously  is  determined  by  the  /PRCLM  user
 authorization quota that has been established for each user on your
 system.  Other quotas that may affect the use of  subprocesses  are
 /ENQLM  (Queue  Entry  Limit), /ASTLM (AST Waits Limit), and /FILLM
 (Open File Limit).

 The creation of a child process is done within the  parent  process
 with  the  exec and vfork functions.  Other functions are available
 to allow the parent  and  child  to  read  and  write  data  across
 processes  (pipe),  and  to  allow  for  synchronization of the two
 processes (wait).

 The implementation of the RTL functions VFORK and EXEC were changed
 in  VAX C V1.4 due to changes in the VMS operating system.  The new
 implementation uses the LIB$SPAWN  system  library  routine  rather
 than  the SYS$CREPRC system service.  This change in implementation
 imposes two new restrictions on the use  of  these  RTL  functions.
 Firstly,  LIB$SPAWN  requires  that DCL be available to the calling
 process and hence, VFORK and EXEC cannot be invoked from a detached
 process.   Secondly,  LIB$SPAWN denies sharing of process permanent
 files between parent and child processes.  Thus, for  example,  the
 user's  terminal (on input) and a batch log file (on output) cannot
 be used by the child process;  they will be  passed  to  the  child
 process as the null device, NLA0:.

 This release note will describe the implementation and use of these
 functions.



 1.0  THE IMPLEMENTATION OF CHILD PROCESSES IN VAX C

 Child processes are created by VAX C  functions  with  the  VAX/VMS
 LIB$SPAWN  Run-Time  Library  Routine.   (See the "VAX/VMS Run-Time
 Library Reference Manual" for information on LIB$SPAWN.) The use of
 LIB$SPAWN  allows you to create multiple levels of child processes.
 That is, the parent's children can also spawn children, and so  on,
 up  to  the  limits  allowed by the user authorization quotas noted
 above.

 Child processes are restricted in that they can execute only  other
 VAX  C  programs.  Other native-mode VAX/VMS languages do not share
 VAX C's ability to communicate between processes, or, if  they  do,
 they  do  not  use  the  same  mechanisms.  In addition, the parent
 process must be run under a Digital-supported CLI, such as the DCL.
 The parent may not be run as a detached process or under control of
 a user-supplied CLI.

 Parent and child processes communicate through a mailbox  shown  in
 the  figure below.  This mailbox transfers the context in which the
 child will run.  The context mailbox, as it is  called,  passes  to
 the  child the information it inherits from the parent, such as the
 names and file descriptors of all the files that have  been  opened
 by  the  parent  and  the current location within those files.  The
 mailbox is deleted by the parent when the child image exits.

 The  mailboxes  created  by  the  vfork  and  exec  functions   are
 temporary.   They  are  created  with  a maximum message size and a
 buffer quota of 512 bytes each.  You need the TMPMBX  privilege  to
 create  a  mailbox  with  these  run-time functions.  TMPMBX is the
 privilege required by the PRINT and SUBMIT DCL  commands.   Chances
 are  that all users on your system have this privilege.  If you are
 not sure, type SHOW PROCESS/PRIVILEGES;  it will show which  system
 privileges you have.

 You cannot change the characteristics of these mailboxes.  For more
 information on mailboxes, see the "VAX/VMS I/O User's Guide."


        -----------         -----------         -----------
        |         |context  |         |context  |         |
        | Parent  |========>| Mailbox |========>|  Child  |
        |         |         |         |         |         |
        -----------         -----------         -----------


      Communications Links Between Parent and Child Processes





 2.0  THE VFORK FUNCTION

 The vfork function provided by VAX C differs from the fork function
 provided by other C compilers.  The two major differences are:


  The Vfork Function             The Fork Function

  Used with exec                 Can  be  used  without  exec  for
                                 asynchronous processing

  Creates an independent child   Creates an exact duplicate of the
  process that shares some of    parent process;  as if the two
  the parent's characteristics   were  the   same   process   that
                                 branches  at the point where fork
                                 is called.


 The vfork function provides the setup necessary  for  a  subesquent
 exec  call.   Although  it  does  not actually create a subprocess,
 vfork performs the following steps:

  o  Saves the return address (the address of the vfork call) to  be
     used later as the return address for the exec call.

  o  Duplicates the parent's stack frame.

  o  Returns 0 the first time it is called, that is, before the exec
     call has been made.  After the corresponding exec call has been
     made exec returns control to the parent process at the point of
     the  vfork  call  and it returns the process id of the child as
     the return value.  Thus, unless exec fails, control  will  seem
     to  return  twice  from  vfork even though one call was made to
     vfork and one call was made to exec.

 The behavior of the vfork function is similar to  the  behavior  of
 the  setjmp  function.   That is, both vfork and setjmp establish a
 return address for later use, both return 0  when  they  are  first
 called  to  set  up this address, and both pass back a second value
 returned by their corresponding exec and longjmp function calls.



 3.0  THE EXEC FUNCTIONS

 There are four functions that can be called  to  execute  a  VAX  C
 image  in the child process.  These functions expect that vfork has
 been called to set up a return address.  When vfork  is  called  by
 the parent, exec returns to the parent process.  When vfork has not
 been called by the parent, then  the  exec  function  calls  vfork.
 When exec calls vfork, it returns to itself, waits for the child to
 exit, and then exits the  parent  process.   Thus,  exec  does  not
 return  to the parent process unless the parent calls vfork to save
 the return address.

 All four functions pass the name of the image to  be  activated  in
 the  child.   They  differ  in  the  way  they  pass  arguments and
 environment information to the child:

  o  Arguments can be passed in separate  character  strings  (execl
     and  execle)  or  in  an  array of character strings (execv and
     execve).

  o  The environment can be explicitly passed in  an  array  (execle
     and  execve) or taken from the parent process implicitly (execl
     and execv).

 The  exec  routines  use  the  LIB$SPAWN  routine  to  create   the
 subprocess  and  activate  the  child  image within the subprocess.
 This child process will inherit the parent's environment, including
 all  defined logical names.  The exec routines use the logical name
 CC$EXECMBX to communicate between parent and child;   this  logical
 name must not exist outside the context of the parent image.

 The exec functions pass the following information to the child:

  o  The parent's umask value, which specifies whether any access is
     to be disallowed when a new file is created.

  o  The file name string associated with each file  descriptor  and
     the  current  position  within  each file.  The child opens the
     file and calls lseek to position the file to the same  location
     as  the  parent.   Note  that if the file is a record file, the
     child is positioned on a record boundary, even if the parent is
     positioned somewhere in the middle of the file.

     This information is sent to the child for all descriptors known
     to  the  parent  including all descriptors for open files, null
     descriptors, and duplicate descriptors.

     Note that file pointers are not transferred to the child.   All
     file  pointers map onto a file descriptor.  For files opened by
     file pointer in  the  parent,  only  their  corresponding  file
     descriptors  are  passed  to  the child.  Therefore, the fdopen
     function must be called to associate a file  pointer  with  the
     file  descriptor  if  the  child  will  access the file by file
     pointer.

  o  The signal  data  base.   Only  SIG_IGN  (ignore)  actions  are
     inherited.   Actions  specified  as  routines  are  changed  to
     SIG_DFL (default) because these routines  are  inaccessible  to
     the child.

  o  The environment and argument vectors.

 When everything has been transmitted to the child, exec  processing
 is  complete.   Control  in  the parent process then returns to the
 address saved by vfork and the child's process id  is  returned  to
 the parent.

 The exec routines can only fail if LIB$SPAWN is  unable  to  create
 the  subprocess, for example, due to exceeding the subprocess quota
 or if the communication via the context mailbox between the  parent
 and  child  is  broken.   Note  that exceeding some quotas will not
 cause LIB$SPAWN to fail, but rather to be put  into  a  wait  state
 that  can  cause the parent process to "hang." An example of such a
 quota is the "open file limit" quota.

 You will need an open file limit of at least 20, with an average of
 three  times  the  number of concurrent processes that your program
 will run.  If you use more than one open pipe at a time, or perform
 I/O  on  several  files at one time, this quota may need to be even
 higher.  See  your  system  manager  if  this  quota  needs  to  be
 increased.

 When an exec fails, a value  of  -1  is  returned.   After  such  a
 failure,  the  parent  is expected to call either the exit or _exit
 routine.  Note that the exit routine will flush and close any  open
 files, which may not be desired.  Both routines will then return to
 the parent's vfork call, returning the child's process id.

 If control returns from the exec function, the  spawn  has  failed.
 The  vfork  function must be followed by either an exec or an _exit
 function call.  If the exec fails, an _exit or  a  return  must  be
 issued  in  order to clean up the environment created by the vfork.
 The value returned from exec will be a  negative  value  indicating
 failure.



 4.0  SYNCHRONIZING PROCESSES WITH WAIT

 A child process is terminated when the parent  process  terminates.
 Therefore,  the  parent  process must check the status of its child
 processes before exiting.  This is  done  with  the  wait  run-time
 function.

 Wait suspends the parent process until a value is returned from the
 child.   This  value  is  the  final status of the child.  The wait
 function can accept an optional  parameter  --  the  address  of  a
 location  to  receive  the  final  status  of the terminated child.
 Thus, the child can set the status with the exit function  and  the
 parent can pick up this value by specifying the optional parameter.

 If more than one child process is running, wait  returns  the  most
 recent return value.  Subsequent calls to wait return the next most
 recent value, and so on.



 5.0  READING AND WRITING DATA THROUGH PIPES

 The pipe run-time function sets up a temporary mailbox for  reading
 and  writing  data  between  the  parent  and  child.  The channels
 through which the processes communicate are  called  a  "pipe".   A
 pipe is implemented as an array of file descriptors associated with
 a mailbox.  The file descriptors are allocated as follows:

  o  The first available file descriptor is assigned to writing  and
     the next available file descriptor is assigned to reading.

  o  The file descriptors are then placed in the  array  in  reverse
     order;   element 0 contains the file descriptor for reading and
     element 1 contains the file descriptor for writing, as shown in
     the figure below.

           Parent                                   Child
        -----------         -----------         -----------
      0 | read    |<========|         |========>| read    | 0
        |---------|         | Mailbox |         |---------|
      1 | write   |========>|         |<========| write   | 1
        -----------         -----------         -----------

                      Implementation of a Pipe


 The mailbox that is used for the pipe is a temporary mailbox.   The
 mailbox  is not deleted until all processes that have open channels
 to it are terminated.  Each process that closes a previously active
 channel to the mailbox writes a zero-length message to the mailbox,
 indicating end-of-file.

 The mailbox is created with the $CREMBX system service,  specifying
 the following characteristics:

  o  Maximum message length of 512 characters

  o  Buffer quota of 512 characters

  o  A protection mask granting all privileges to USER and GROUP and
     no privileges to SYSTEM or WORLD.

 The buffer quota of 512 characters implies that no  more  than  512
 characters  can be written to the mailbox before all or part of the
 mailbox is read.  Since a mailbox record is  slightly  larger  than
 the  data  part of the message that it contains, not all of the 512
 characters can be used for message data.

 The pipe is created by the parent process before vfork and exec are
 called.   By  calling  pipe first, the child inherits the open file
 descriptors for the pipe.  The getname function can then be used to
 return  the  name  of the mailbox associated with the pipe, if this
 information is desired.   The  mailbox  name  returned  by  getname
 always has the format "_MBAnnnn:", where "nnnn" is a unique number.

 Both the parent and the child need to know in  advance  which  file
 descriptors  will  be  allocated  for  the  pipe.  This information
 cannot be retrieved at run time.  Therefore,  it  is  important  to
 understand how file descriptors are used in any VAX C program.

 File descriptors 0, 1, and 2 are always open in a VAX C program for
 SYS$INPUT,  SYS$OUTPUT, and SYS$ERROR, respectively.  Therefore, if
 no other files have been opened when pipe is called,  pipe  assigns
 file  descriptor  3  for writing and file descriptor 4 for reading.
 In the array returned by pipe, 4 is placed in element 0  and  3  is
 placed in element 1.

 If other files have been opened, pipe assigns the  first  available
 file  descriptor for writing and the next available file descriptor
 for reading.  Note that in this case, the pipe does not necessarily
 use  adjacent file descriptors.  For example, assume two files have
 been opened and assigned to file descriptors 3 and 4 and the  first
 file  is  then  closed.   If  pipe  is  called  at this point, file
 descriptor 3 will be assigned for writing  and  file  descriptor  5
 will  be assigned for reading.  Element 0 of the array will contain
 5 and element 1 will contain 3.

 In large applications that do a lot of I/O,  it  gets  increasingly
 more  difficult  to  predict which file descriptors are going to be
 assigned to a  pipe.   And,  unless  the  child  knows  which  file
 descriptors  are  being used, it will not be able to read and write
 successfully to and from the pipe.

 One way to be sure that the correct file descriptors are being used
 is to follow the procedure outlined below:

 1.  Choose two descriptor numbers that will be known  in  both  the
     parent and the child.

 2.  Call pipe in the parent at some point before calling exec.

 3.  In the parent, use dup2 to assign the file descriptors returned
     by  pipe  to the file descriptors you chose.  This now reserves
     those file descriptors for the pipe;  any subsequent  I/O  will
     not interfere with the pipe.

 Reading and writing through the pipe can be done with the UNIX* I/O
 functions   read   and   write,  specifying  the  appropriate  file
 descriptors.  As an alternative, you  can  issue  fdopen  calls  to
 associate file pointers with these file descriptors so that you can
 use the standard I/O functions (fread and fwrite).

 Although two separate file descriptors are used  for  reading  from
 and  writing  to the pipe, only one mailbox channel is used.  Thus,
 some I/O synchronization is required.  For example, assume that the
 parent  writes  a  message to the pipe.  If the parent is the first
 process to read from the pipe, then it will read  its  own  message
 back.   In the final example below, the required synchronization is
 achieved by means of a wait function call, whereby the parent waits
 until the child terminates before reading from the pipe.  This form
 of synchronization is limited in its scope  and  other  alternative
 methods should be investigated.



 6.0  EXAMPLE PROGRAMS

 The first example shows the basic procedures for executing an image
 in a child process.

 1.  Vfork is called to set up the return address for the exec call.

     Typically, vfork is used in the expression of an if  statement.
     This  construct  allows  you  to  take  advantage of the double
     return aspect of vfork, since one return value is zero and  the
     other nonzero.

 2.  A zero return value is returned the first time vfork is  called
     and  the  parent  executes  the  else block associated with the
     vfork call, which calls execl.  Note the use of _exit  to  deal
     with  an  execl  failure.   _Exit does not flush any buffers or
     close open files;  it returns control back to the  vfork  call,
     which handles errors.

 3.  A negative child process id is returned when an  exec  function
     fails  or the child process fails.  Therefore, the return value
     is checked for these conditions.

 4.  Wait is used to synchronize the parent and child processes.

 5.  Since the exec functions can indicate success up to this  point
     even  if the image to be activated in child does not exist, the
     parent checks the child's return status  for  the  RMS  status,
     RMS$_FNF (file not found).

 The child process in this first example simply prints a message  10
 times.


 PARENT:

    #include rmsdef /* to refer to RMS status values symbolically */
    #include stdio

    main()
    {
        int status, cstatus, mode;

        if ((status = vfork()) != 0)

            if (status < 0)
                printf("Parent - Child process failed\n");
            else
                {
                printf("Parent - Waiting for Child\n");
                if ((status = wait(&cstatus)) == -1)
                    perror("Parent - Wait failed");
                else
                    if (cstatus == RMS$_FNF)
                        printf("Parent - Child does not exist\n");
                    else
                        printf("Parent - Child final status: %d\n", 
                         cstatus);
                }
        else
            {
            printf("Parent - Starting Child\n");
            if ((status = execl("child", 0)) == -1)
                {
                perror("Parent - Execl failed");
                _exit();
                }
            }
    }


 CHILD:

    main()
    {
        int i;

        for (i=0; i < 10; i++)
            printf("Child - executing\n");
    }



 In the second example, the parent passes  arguments  to  the  child
 process.   The  arguments  are placed in an array (gargv), but they
 could also be passed to the child explicitly as  a  zero-terminated
 series  of  character  strings.   The child program in this example
 simply writes to SYS$OUTPUT the arguments that have been passed  to
 it.


 PARENT:


    #include rmsdef 
    #include stdio

    main()
    {
        int status, cstatus, mode;
        char *gargv[] = { "Child", "ARGC1", "ARGC2", "Parent", 0 };

        if ((status = vfork()) != 0)

            if (status < 0)
                printf("Parent - Child process failed\n");
            else
                {
                printf("Parent - waiting for Child\n");
                if ((status = wait(&cstatus)) == -1)
                    perror("Parent - Wait failed");
                else
                    if (cstatus == RMS$_FNF)
                        printf("Parent - Child does not exist\n");
                    else
                        printf("Parent - Child final status: %x\n", 
                         cstatus);
                }
        else
            {
            printf("Parent - Starting Child\n");
            if ((status = execv("Child", gargv)) == -1)
                perror("Parent - Exec failed");
            }
    }


 CHILD:


    main(argc, argv)
    int argc;
    char *argv[];
    {
        int i;

        printf("Program name: %s\n", argv[0]);

        for (i = 1; i < argc; i++)
            printf("Argument %d: %s\n", i, argv[i]);
    }


 The next shows how the wait function can be used to check the final
 status  of multiple children being run simultaneously.  The wait is
 placed in a separate for loop so that it is called  once  for  each
 child.

 If wait were called within the first for  loop,  the  parent  would
 wait  for  one  child to terminate before executing the next child.
 If there were only one wait request, any child still  running  when
 wait was called would terminate prematurely.


 PARENT:


    #include rmsdef
    #include stdio

    main()
    {
        int status, cstatus, mode, i;

        for (i = 0; i < 5; i++)
            {
            if ((status = vfork()) == 0)
                {
                printf("Parent - Starting Child %d\n", i);
                if ((status = execl("child", 0)) == -1)
                    {
                    perror("Parent - Exec failed");
                    _exit();
                    }
                }
            else
                if (status < 0)
                    printf("Parent - Child process failed\n");

            }   

        printf("Parent - Waiting for children\n");

        for (i = 0; i < 5; i++)
            { 
            if ((status = wait(&cstatus)) == -1)
                perror("Parent - Wait failed");
            else
                if (cstatus == RMS$_FNF)
                    printf("Parent - Child does not exist\n");
                else
                    printf("Parent - Child %X final status: %d\n",
                        status, cstatus); 
            } 
    }


 CHILD:


    main()
    {
        int pid, i;

        printf("Child %0X: working...\n",(pid = getpid()));
        sleep(5);
        printf("Child %0X: Finished\n",pid);
    }


 The next example shows the use of  pipe  and  dup2  to  communicate
 between   a   parent   and  child  process  through  specific  file
 descriptors.  The #define preprocessor  control  line  defines  the
 preprocessor  constants "inpipe" and "outpipe" as the names of file
 descriptors 11 and 12.

 In this example, the parent writes a string to  the  pipe  for  the
 child  to  read.  The child then writes the string back to the pipe
 for the parent to read.  The wait function  is  called  before  the
 parent  reads the string that the child has passed back through the
 pipe.  Otherwise, the reads and writes would not be synchronized.

 Since there is only one child being executed from the  parent,  the
 status  value  of  the  exec  call is tested in a switch statement.
 Case 0 is executed the first time vfork  is  called.   Case  -1  is
 executed  if the execl call fails.  A switch statement could not be
 used where more than one child is being executed, since the process
 ids  for  children  that  fail  are  assigned  in decreasing order,
 beginning with -1.  The default case is executed when the child  is
 successfully executed and execl has returned a normal child process
 id.  Note that the default case  checks  for  the  file  not  found
 condition, since an exec call cannot detect this condition.


 PARENT:


    #include rmsdef
    #include stdio
    #define inpipe 11
    #define outpipe 12

    main()
    {
        int pipes[2];
        int mode, status, cstatus, len;
        char *outbuf, *inbuf;

        if ((outbuf = malloc(512)) == 0)
            {
            printf("Parent - Outbuf allocation failed\n");
            exit();
            }

        if ((inbuf = malloc(512)) == 0)
            {
            printf("Parent - Inbuf allocation failed\n");
            exit();
            }
        if (pipe(pipes) == -1)
            {
            printf("Parent - Pipe allocation failed\n");
            exit();
            }

        dup2(pipes[0], inpipe);
        dup2(pipes[1], outpipe);
        strcpy(outbuf, "This is a test of two-way pipes.\n");

        status = vfork();
        switch (status)
            {
            case 0: 
                printf("Parent - Starting child\n");
                if ((status = execl("child", 0)) == -1)
                    {
                    printf("Parent - Exec failed");
                    _exit();
                    }
                break;
            case -1:
                printf("Parent - Child process failed\n");
                break;
            default:
                printf("Parent - Writing to child\n");
                if ((write(outpipe, outbuf, strlen(outbuf)+1)) 
                     == -1)
                    {
                    perror("Parent - Write failed");
                    exit();
                    }
                else
                    {
                    if ((status = wait(&cstatus)) == -1)
                        perror("Parent - Wait failed");

                    if (cstatus == RMS$_FNF)
                        printf("Parent - Child does not exist\n");
                    else
                        {
                        printf("Parent - Reading from child\n");
                        if ((len = read(inpipe, inbuf, 512)) <= 0)
                            {
                            perror("Parent - Read failed");
                            exit();
                            }
                        else
                            {
                            printf("Parent: %s\n", inbuf);
                            printf("Parent - Child final status:
    %d\n",
                               cstatus); 
                            }
                        }
                    }
                break;
            }
    }


 CHILD:


    #define inpipe 11
    #define outpipe 12

    main()
    {
        char *buffer;
        int len;

        if ((buffer = malloc(512)) == 0)
            {
            perror("Child - Buffer allocation failed\n");
            exit();
            }

        printf("Child - Reading from parent\n");
        if ((len = read(inpipe, buffer, 512)) <=0)
            {
            perror("Child - Read failed");
            exit();
            }
        else
            {
            printf("Child: %s\n", buffer);
            printf("Child - Writing to parent\n");
            if (write(outpipe, buffer, strlen(buffer)+1) == -1)
                {
                perror("Child - Write failed");
                exit();
                }
            }    
    }



----------
* UNIX is a trademark of Bell Telephone Laboratories.

4 Dynamic_storage
 All of the VAX C run-time library routines that require  additional
 dynamic  storage  get  that  storage  using  the  run-time  library
 allocation/deallocation routines malloc, calloc, free,  and  cfree.
 These  routines  use  the  LIB$GET_VM  and  LIB$FREE_VM routines to
 acquire the additional virtual memory.  LIB$GET_VM and  LIB$FREE_VM
 take  a fair amount of time to supply the virtual memory and, thus,
 the VAX C run-time library attempts to reduce the number  of  calls
 to these functions, in the following manner.

 The VAX C run-time library maintains a pointer block to the  memory
 block  that  was  most recently freed by either free or cfree.  The
 last freed block is not returned to VMS by  LIB$FREE_VM.   Instead,
 the VAX C run-time library attempts to satisfy the next request for
 storage with this saved block.  Any unused portion of this block is
 retained for future allocation requests, provided that it is larger
 than a predefined  minimum  size.   The  size  constraint  prevents
 fragmentation of memory.

 The freeing of a second block causes the saved block to be returned
 to  VMS  through LIB$FREE_VM.  The new block is then saved.  If the
 saved block is too small to satisfy a request, it is  retained  and
 the requested memory is allocated by LIB$GET_VM.

 Because the VAX C run-time library saves the last  freed  block  of
 storage,  there is not a one-to-one correspondence between calls to
 malloc or calloc and LIB$GET_VM or between calls to free  or  cfree
 and  LIB$FREE_VM.   Therefore,  a  program  cannot use these memory
 allocation functions on the same data  in  the  same  program  with
 LIB$GET_VM and LIB$FREE_VM.  The interleaving of calls to the VAX C
 memory allocation routines and the system library memory allocation
 routines  could  cause  the  program  to  attempt  to  allocate  or
 deallocate the same block of storage twice.

 Similarly, the functions brk  and  sbrk  use  the  system  services
 SYS$EXPREG  and  SYS$CNTREG to expand and contract the virtual (P0)
 address  space.   Since  there  is  not  necessarily  a  one-to-one
 correspondence  between calls to these run-time functions and their
 underlying system services, it is recommended that the brk and sbrk
 routines   not   be   interleaved  with  calls  to  SYS$EXPREG  and
 SYS$CNTREG.

 In addition, LIB$GET_VM and LIB$FREE_VM  are  not  compatible  with
 SYS$EXPREG  and  SYS$CNTREG.   Hence,  the  VAX C memory allocation
 routines are not compatible with the brk and sbrk routines.

4 Shareability
 Certain modules in the VAX C run-time library (most notably, stdio)
 contain  initialized  extern  variables.  This makes a program that
 references the VAX C run-time library unsuitable for  incorporation
 into a shared image.

 Extern  variables  are  defined  in  program  sections  having  the
 attributes  WRT  (writeable) and SHR (shareable).  These attributes
 are not appropriate for variables  that  must  be  unique  to  each
 process that runs the program, such as loop counters or pointers to
 the current position within a file.  Variables like these  must  be
 made  "copy-on-reference," which provides each process with its own
 copy of the variable.  A variable is  made  "copy-on-reference"  by
 declaring  it  with the globaldef keyword.  Globaldef variables are
 defined in program sections having the attributes  WRT  (writeable)
 and  NOSHR  (not shareable).  Page 235 of "Programming in VAX-11 C"
 contains a table listing all the  attributes  of  program  sections
 created by VAX C.

4 ASTs
 A VAX C routine, if set up as a signal routine, will be executed at
 AST  level.   If  a  longjmp is done out of the signal routine to a
 setjmp in the mainline code, you will  continue  executing  at  AST
 level.

 In the VAX Run-Time Library documentation, it states the following:

    "When  an  external  event  occurs,  VAX/VMS  interrupts  the
    execution  of  the current process and calls a procedure that
    you supply.  While that procedure is active, the AST is  said
    to be in progress, and the process is said to be executing at
    AST level.  When your AST procedure returns  control  to  the
    original  process,  the AST is no longer active and execution
    continues where it left off."

 When a VAX  C  main  program  gets  control,  the  address  of  the
 condition handler, c$$cond_hand, is set at 0(FP).  This sets up the
 VAX C condition handler which is part  of  the  C  RTL.   When  any
 condition   occurs,  that  handler  gets  control,  translates  the
 condition into a  UNIX*  condition  value,  and  takes  the  action
 specified  by the user.  If a routine was supplied, that routine is
 called.  The process will continue at AST level until  the  routine
 returns  to  the VAX C handler and the handler returns to VMS.  The
 process cannot get out of the AST state until that final return  is
 performed.

 A longjmp must, therefore, not  be  performed  from  an  AST  level
 routine  when the corresponding setjmp was issued from the mainline
 code.  However, it is valid to  issue  a  setjmp  from  within  the
 signal  routine  and  then  a subsequent longjmp, both while at AST
 level.

 ----------
 * UNIX is a trademark of Bell Telephone Laboratories.

4 Creat
 The "rat=blk" keyword to the VAX C  function  creat  works  in  the
 opposite  sense to that given on page 105 of "Programming in VAX-11
 C."

 When any of the keywords listed on page 105 are included in a  call
 to  creat,  the C run-time library sets the keyword's corresponding
 field in the RMS file control structures.  For any keyword that  is
 not  included  in  the  call,  the  C run-time library uses the RMS
 default for the keyword's corresponding field.

 In the case of "rat=blk", the default is to allow records  to  span
 block  boundaries.   Thus,  you  specify  this  record attribute by
 leaving that keyword out  of  the  creat  call.   You  include  the
 keyword when you do not want records to span block boundaries.

4 CR_CTRL
 The VAX C run-time library conversion of FORTRAN  carriage  control
 records  to  stream  format  was  incorrect.  The interpretation of
 these records was fixed in V1.4.  The correct  simulations  are  as
 follows:

    NULL    ->   \r <record>
    0       ->   \n \n <record> \r
    1       ->   \f <record> \r
    +       ->   <record> \r
    $       ->   \n <record>

    Page 80 of "Programming in VAX-11 C" will be updated in the next
    release of that book.

4 Ftell
 When using record files, all fseek, lseek, and I/O operations  must
 be  performed  on record boundaries.  The ftell function returns an
 invalid value if it is invoked at other than a record boundary when
 using stream I/O functions on a record file.  Unpredictable results
 are  obtained  from  fseek  when  the  offset  specified  does  not
 correspond to a record boundary.  The fgets (if the record contains
 a newline or carriage return at the end of  each  record)  or  read
 function  should  be  used  in  order to obtain valid ftell results
 since entire records are returned by  these  functions.   Refer  to
 Section  6.1.1.3, Stream Access to Record Files, in "Programming in
 VAX-11 C."

 Note that there is a documentation error in "Programming in  VAX-11
 C"  regarding  the  value  returned by ftell.  It should read that,
 with record files,  ftell  returns  the  position  of  the  current
 record,  not  the  next  record.  Thus, after an fgets operation, a
 call to ftell will return the position  of  the  beginning  of  the
 record just read.

4 Mixed_IO

 When a program  both  reads  and  writes  a  file,  it  must  write
 ("flush") the I/O buffer before switching from one operation to the
 other.  The simplest way to write the buffer is by calling  fflush.
 However,  fseek,  rewind, fclose, and freopen also write the buffer
 as part of their operation.

 This requirement was not documented in "Programming in VAX-11 C."

4 Open_File_Limit

 The standard I/O functions  which  access  files  by  file  pointer
 restrict  the  number  of concurrently opened files to a maximum of
 20.  The files stdin, stdout,  and  stderr  are  included  in  this
 number.    Therefore,   when  accessing  files  with  standard  I/O
 functions, you may have, at most, 17 additional concurrently opened
 files.   This  restriction is consistent with other implementations
 of the C run-time library.

 Note that  this  restriction  is  not  imposed  by  the  UNIX*  I/O
 functions or by RMS.



 ----------
 * UNIX is a trademark of Bell Laboratories.

4 Read_Restriction
 The read run-time function reads no more than  65,535  bytes  at  a
 time.   This is a restriction in the VAX C run-time library imposed
 by a similar restriction in RMS.

 The return value from read is  the  actual  number  of  bytes  read
 (which  is  not guaranteed to be the number requested).  Because of
 the underlying RMS restriction, it is  not  anticipated  that  this
 restriction wil be removed in the near future.

4 setjmp_longjmp
 Page 145 of "Programming in VAX-11  C"  explains  that  the  setjmp
 function saves the contents of the general-purpose registers in the
 jmp_buf buffer.  This buffer is restored by the longjmp function.

 It should be noted that some variables that are local to a function
 may be stored in the general-purpose registers.  Thus, when longjmp
 restores the registers, the values of  these  local  variables  are
 also restored to their setjmp values.

4 close_conflict
 When writing programs that  consist  of  both  VAX  C  and  FORTRAN
 modules,  a  conflict  can  occur  between the VAX C close run-time
 function and the VAX/VMS CLOSE Run-Time Library  routine.   If  the
 program  is  linked  first  with the VAX C run-time library and the
 FORTRAN program contains  a  CALL  CLOSE  statement,  the  call  is
 resolved to the VAX C close run-time function.  The FORTRAN program
 should use a CLOSE statement rather than a CALL CLOSE statement.  A
 CLOSE  statement is resolved to the FOR$CLOSE routine (contained in
 STARTLET.OLB and the VMS Run-Time Library).

3 #include
 Preprocessor control lines of the form

    #include "file-specification"

 cause the compiler to look for the specified file in one  directory
 only.   The  directory searched is either the same directory as the
 source file or, if a directory specification  is  given,  only  the
 specified  directory.   If  the include file does not exist in that
 directory, the compilation is aborted.

3 Portability
 Some users have noticed that warning messages  are  issued  against
 several  of  the  VAX  C  #include files when /STANDARD=PORTABLE is
 specified in the command line.  It should be noted that the use  of
 these  #include  files  in  a  program  does  not  make the program
 non-portable, despite the issuance of  the  warning  message.   The
 purpose   of   #include   files   is   to   hide   system-dependent
 implementation  differences  from  the  program   (and   from   the
 programmer)  and  to  maintain  an identical, or consistent, system
 interface between the various  implementations.   It  is  only  the
 content of such files that may not be portable, not necessarily the
 program that uses them.

 In particular, the NONPORTSC  warning  message  is  issued  against
 those  #include files that contain declarations of certain external
 variables.  These variables represent  intialized  control  blocks,
 tables,  and  other data that are defined within modules located in
 the VAX C run-time library.  When a program that  includes  any  of
 these  files  is  linked,  the  Linker must extract the appropriate
 modules  from  the  C  run-time  library  to  resolve  the  exteral
 references  correctly.   In  order for the linker to extract such a
 module, however, the program being linked must contain a  reference
 to a global symbol that is defined in that module.

 In VAX C, external variables are implemented  as  program  sections
 (psects),  whose  names  are  the same as the variable names.  This
 provides for direct sharing of data  between  VAX  C  programs  and
 programs  written  in other VAX/VMS languages.  Psect names are not
 global symbols, however, and are  therefore  not  resolved  by  the
 Linker in the same manner as global symbols.  In order to cause the
 Linker to include  pre-defined  data  from  a  library  module,  it
 requires  that  a reference to a dummy global symbol be declared in
 the #include file and the corresponding dummy symbol be defined  in
 the library module.

 Although this use of global symbols is system-dependent  and  thus,
 not  portable,  the  interface  between  the  program, the run-time
 function being called, and the #include file  is  still  consistent
 with other implementations of the C language.

3 Typedefs
 In V1.0 of VAX C, the names of typedefs could not  be  spelled  the
 same  as  structure  and  union member names.  This restriction has
 been lifted in V1.1.

3 Enum_Types
 On page 35 of "Programming in VAX-11 C" (order number AA-L370A-TE),
 there  are  a number of program fragments that deal with enumerated
 variables.  The book states that it is an error to  assign,  to  an
 enum  variable,  an  enumerator  or  other value that is not in the
 enumerator list for that type, as in the statements:

        enum spectrum
            { 
            red, orange, yellow, green, blue, indigo, violet
            } color1;

        enum illum
            {
            out, verydim, dim, prettybright, bright
            } light;

        light = red;
        light = 1;

 The book did not state that the diagnostic message associated  with
 this  error  is  issued  only  if  you  use  the /STANDARD=PORTABLE
 qualifier in the CC command line.

 The book  showed  the  correct  way  to  perform  valid  mixed-type
 operations using the cast operator, as in:

    light = (enum illum) 1;

 However, the V1.0 VAX C compiler did not handle the cast  operation
 correctly  when  attempting  to cast an expression to an enumerated
 type and it issued a diagnostic  message  against  this  statement.
 VAX C V1.1 imposes stricter contraints on the interchangeability of
 enumerated and integer-valued expressions than other C compilers.

 In addition, the other example from page 35,

    light = out + (enum illum) red;

 is not valid;  the  addition  of  two  enum-valued  expressions  is
 defined  to  yield an integer, which cannot be directly assigned to
 an enumerated type without casting it.  The correct statement is:

    light = (enum illum) (out + (enum illum) red);

 To help avoid furthur confusion about enumerated variables and  the
 operations that can be performed on them, the ENUMOP diagnostic has
 been  changed  and  another,  ENUMCLASH,  has  been  added.   These
 messages  occur  only when the /STANDARD=PORTABLE qualifier is used
 in the CC command line.

 These two messages have been included in the VAX C V1.1 help files.
 For a full description of them, type:

    $ HELP CC ERROR ENUMCLASH
    $ HELP CC ERROR ENUMOP

 The formal documentation for these messages will be  updated  in  a
 subsequent release of VAX C.

3 Global_Enums
 In V1.0 of VAX C, there was  an  error  in  the  way  the  compiler
 processed  global  enumerated  types.   This  problem  could  cause
 unexpected or erroneous program behavior.

 According to page 245 of "Programming in VAX-11  C"  (order  number
 AA-L370A-TE) when an enumerated variable is declared with either of
 the  storage  classes  globaldef  or  globalref,   the   enumerator
 constants  in  the  declaration  become globalvalues.  In V1.0, the
 compiler treated the enumerators as having known values, regardless
 of  the  storage class specified.  The compiler always assumed that
 an enumerator constant had the value specified or  implied  by  its
 position in the enumerator list.

 For example, in the declaration

    globalref enum { a, b = 2, c } gre;

 the enumerator constants a, b, and c were given the  values  0,  2,
 and  3 by the V1.0 compiler.  Note, however, that if an enumeration
 declaration specifies the globalref storage class,  the  values  of
 the enumerators should not be known to the compiler.  Instead, they
 should be determined by the values specified in  the  corresponding
 globaldef declaration of the same enumeration in some other module.
 That is, the values of the enumerators should be resolved  at  link
 time.   In  the  above  example,  the  compiler  issued the GBLENUM
 warning message but it initialized the enumerators anyway.

 As a consequence, the compiler also allowed these enumerators to be
 used  in  the  same manner as compile-time constants.  For example,
 the above enumerators a, b, and c were allowed as  case  labels  in
 switch statements, as array bounds, and as initializers.

 Therefore, in  any  enumeration  declaration  which  specifies  the
 globalref storage class, the following changes have been made:

  o  All of the  enumerators  are  considered  to  be  uninitialized
     globalvalues, whose values cannot be known until link time.

  o  The GBLENUM warning message is now  correct;   the  enumerators
     are   not   initialized  and  any  values  specified  with  the
     enumerators will be ignored.

 As a result of these changes, such enumerator constants  cannot  be
 used in any context in which uninitialized globalvalues cannot also
 be used.

3 Struct_Union_References
 The way in which VAX C V1.0 resolved  structure  and  union  member
 references  was  not  in  keeping  with  recent  changes  to  the C
 language.  That is, a reference to a structure or union member  did
 not have to be fully qualified if it was unambiguous.  (See page 41
 of "Programming in VAX-11 C," order number AA-L370A-TE).  This  was
 due  to  the fact that, in a structure reference, the offset of any
 member of a structure was calculated  from  the  beginning  of  the
 structure,   regardless   of  whether  the  member  belonged  to  a
 substructure.  For example, in the structure definition

        struct 
            {
            int a;              /* Offset 0 */
            struct
                {
                int b, c;       /* Offsets 4 and 8 */
                } d;            /* Offset 4 */
            } e;

 you could make a reference to  e.b,  leaving  out  the  intervening
 qualifier d, to yield the member b.

 The same held true for unions.  That is, in the definition

        struct
            {
            int a;          /* Offset 0 */
            union
                {
                int b, c;   /* Both at offset 4 */
                } d;        /* Offset 4 */
            } e;

 any references to b or c did not require the intervening  qualifier
 d.

 V1.1 of VAX  C  now  calculates  the  offsets  of  the  members  of
 structures  and  unions  differently  and  all  structure and union
 member references must be fully qualified.  This change should make
 VAX C more compatible with other C compilers.

 In V1.1, the offset of a member of a  structure  or  union  is  the
 relative  offset from the base of its enclosing structure or union.
 Going back to the first example,

        struct 
            {
            int a;              /* Offset 0 */
            struct
                {
                int b, c;       /* Offsets 0 and 4 from d */
                } d;            /* Offset 4 */
            } e;

 a reference to e.b is incorrect (yields member a).  A reference  to
 b  must  have  the form e.d.b.  The same is true for unions, except
 that members b and c are both at offset 0  from  the  base  of  the
 union d.

 The  compiler  will  issue  the  NONSEQUITUR  warning  message  for
 programs  that  do  not  use  fully-qualified  structure  and union
 references when the /STANDARD=PORTABLE option is  used  in  the  CC
 command  line.  These programs should be changed.  The way in which
 the offsets are now calculated can cause  these  programs  to  have
 unpredictable behavior.

 As a result of this change, the  following  definition  files  (and
 corresponding  library  modules)  have  been  changed  in  order to
 simplify references to the structure and union members  which  they
 declare:

  o  OPCDEF.H

  o  SECDEF.H

  o  RAB.H

  o  NAM.H

  o  FAB.H

  o  XAB.H

  o  RMS.H

 Except for the definition of  extended  attribute  blocks  (XAB.H),
 these  changes  should not affect your programs.  To make sure your
 references    are    correct,    you    should    recompile    with
 /STANDARD=PORTABLE any V1.0 programs that #include these definition
 files  or  modules.   If  a  reference  is  no  longer  correct,  a
 diagnostic  message  will  point  to the reference that needs to be
 changed.  By listing the .H file in question, you will be  able  to
 determine the correct way to reference the member.

 Programmers using RMS should change their programs as described  in
 HELP CC RELEASE_NOTES RMS_CHANGES.

3 RMS_Changes
 The V1.0 compiler resolved structure and union member references in
 a  way which was inconsistent with other C compilers.  (See HELP CC
 RELEASE_NOTES STRUCT_UNION_ REFERENCES.) The  V1.0  interface  with
 RMS  took advantage of the old method for resolving such references
 in extended attribute blocks.   Subsequently,  the  RMS  definition
 files  had  to  be  rewritten.   Of the RMS definition files, XAB.H
 changed the most.

 The xab #include module now provides seven separate structures, one
 for  each  type  of  extended attribute block.  The following table
 lists the new structure tags  and  the  prototype  structures  with
 which you initialize them.

    Structure Tag   Prototype

       XABALL       cc$rms_xaball
       XABDAT       cc$rms_xabdat
       XABFHC       cc$rms_xabfhc
       XABKEY       cc$rms_xabkey
       XABPRO       cc$rms_xabpro
       XABRDT       cc$rms_xabrdt
       XABSUM       cc$rms_xabsum

 Existing programs that #include the XAB definition file  will  have
 to be rewritten.  These programs should be recompiled with the V1.1
 compiler using the /STANDARD=PORTABLE qualifier on the  CC  command
 line.   If  a  reference is no longer correct, a diagnostic message
 will point to the reference that needs to be changed.   By  listing
 the  XAB.H  file,  you  will  be  able  to  determine  the  correct
 reference.

 Please refer to Chapter 8  of  "Programming  in  VAX-11  C"  (order
 number  AA-L370A-TE) for more information on the VAX C interface to
 RMS.

3 Bit_Fields
 The  VAX  C  implementation  of  bit  fields  was  not   adequately
 documented in "Programming in VAX-11 C" (order number AA-L370A-TE).
 On page 44 it states that, "The  use  of  field  types  other  than
 unsigned  or  int is an error." In both V1.0 and V1.1 of VAX C, bit
 fields declared as types unsigned, int, and  enum  are  treated  as
 unsigned  and do not produce a diagnostic message.  Fields declared
 as any other type are also converted to unsigned but  the  compiler
 issues the FIELDBADTYPE warning-level message.

 This treatment of bit fields is stricter than, but consistent with,
 the  "C  Reference  Manual"  which  states,  "The language does not
 restrict the types of things  that  are  declared  as  fields,  but
 implementations are not required to support any but integer fields.
 Moreover, even int fields may be considered to be unsigned."*

 The text of the FIELDBADTYPE message has been  made  more  precise.
 You can type

    $ HELP CC ERROR FIELDBADTYPE

 to read the new message that accompanies this  error.   The  formal
 documentation  of  bit  fields and the FIELDBADTYPE message will be
 updated in a future release of "Programming in VAX-11 C."



 __________
 * Brian W.  Kernighan and Dennis M.  Ritchie,  "The  C  Programming
 Language" (Englewood Cliffs, New Jersey;  Prentice-Hall, 1978) page
 197.

3 Debugger_Support
 Pages 341 and 342  of  "Programming  in  VAX-11  C"  (order  number
 AA-L370A-TE) state that floating-point variables cannot be examined
 by the debugger.  A recent change in debugger support  allows  such
 variables  to  be  examined  now.   The new qualifiers /F_FLOAT and
 /D_FLOAT  allow  you  to  examine   floating-point   variables   in
 F_floating    binary   format   and   D_floating   binary   format,
 respectively.  As a  result  of  this  change,  Example  15-4  also
 changes:

     DBG>SET BREAK %LINE 8
     DBG>GO
     routine start at MAIN
     break at MAIN\%LINE 8
     DBG>GO
     routine start at MAIN
     break at MAIN\%LINE 8
     DBG>GO
     routine start at MAIN
     break at MAIN\%LINE 8
     DBG>SET TYPE/OVERRIDE F_FLOAT
     DBG>EXAMINE arr
     MAIN\ARR: 0.0000000E+00
     DBG>EXAMINE
     652: 3.0000001e+00
     DBG>EXAMINE
     656: 6.0000002e+00
     DBG>EXIT

3 New_Modules
 The dvidef definition module has been added to the VAX  C  library,
 SYS$LIBRARY:CSYSDEF.TLB.   This  module contains the $GETDVI system
 service request code definitions.  Similarly, the msgdef definition
 module has been added to SYS$LIBRARY:CSYSDEF.TLB.  This module con-
 tains system mailbox message definitions.  Both  of  these  modules
 are also available as ".h" files located in SYS$LIBRARY:  as well.

 Appendix E of "Programming in VAX-11 C" (order number  AA-L370A-TE)
 will be updated in a subsequent release.

3 Arithmetic_Conversions
 The VAX C implementation  of  the  "usual  arithmetic  conversions"
 conflict  slightly with the implementation implied by Kernighan and
 Ritchie.* The rules for VAX C arithmetic conversion are  documented
 in  Section  4.1.1  of  "Programming  in  VAX-11  C"  (order number
 AA-L370A-TE).   In  VAX  C,  the  long  and  int  data  types   are
 equivalent.   This  equivalence  can  cause  an  expression  to  be
 evaluated differently on other compilers  that  may  implement  the
 Kernighan and Ritchie rules literally.



 ____________
 * Kernighan, Brian W., and Ritchie, Dennis M., "The  C  Programming
 Language" ( Englewook Cliffs, New Jersey:  Prentice Hall, 1978 ) p.
 184.

3 Run_Time_Errors
 Page 316 of "Programming in VAX-11 C"  (order  number  AA-L370A-TE)
 describes  the  messages  that  are displayed when a run-time error
 occurs.  The VAX C error message

    %C-F-ERROR, C error condition

 is no longer returned.  Only the message returned  by  the  VAX/VMS
 condition handler and the traceback information are returned.

3 atof_atoi_atol
 The string to be converted by atof, atoi,  or  atol  terminates  on
 either  the  end of the string or the first character that does not
 parse according to  the  format  specified  in  Section  6.11.9  of
 "Programming in VAX-11 C" (order number (AA-L370A-TE).

3 Module_Names
 The following are restrictions on the form of a module name  in  an
 #include preprocessor control line:

 The module name that the VAX C compiler  accepts  must  follow  the
 same  rules  as  for  a  valid  VAX  C identifier.  That is, it can
 consist of letters, digits, the dollar sign ($) and the  underscore
 character (_);  the first character must not be a digit.

 Additionally, the module name is converted to uppercase before  the
 compiler searches the text library.

3 setbuf_Restriction
 For this release, the setbuf run-time library  function  cannot  be
 used  with  the  printf  and  fprintf  functions.  In addition, the
 buffer named in a call to setbuf must be declared with  either  the
 extern or static storage class.


